diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..bf8d1c1283d117c0d36ee9448500ee0eab36ab3e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0.js @@ -0,0 +1,464 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_0", + "is_composite": true, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100000]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["gradient", "opacity", "radius_corner"], + "min_height": 300, + "min_width": 300, + "background": "light", + "has_title": "yes", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const titles = jsonData.titles || {}; + const metadata = jsonData.metadata || {}; + + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + + const rawRows = chartData.map((d, i) => ({ + sourceIndex: i, + category: String(d[xField] ?? ""), + value: +d[yField] + })).filter(d => Number.isFinite(d.value) && d.category); + + const isTimeLikeField = /year|date|month|time|season|semester|quarter/i.test(String(xField || "")); + const monthIndex = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, + sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, + dec: 12, december: 12 + }; + function timeKey(label) { + const s = String(label || "").trim().toLowerCase(); + const year = s.match(/\b(19|20)\d{2}\b/); + if (year) return +year[0]; + const month = monthIndex[s] || monthIndex[s.slice(0, 3)]; + if (month) return month; + const parsed = Date.parse(s); + return Number.isFinite(parsed) ? parsed : null; + } + + const processedData = [...rawRows].sort((a, b) => { + if (isTimeLikeField) { + const ak = timeKey(a.category); + const bk = timeKey(b.category); + if (ak !== null && bk !== null && ak !== bk) return ak - bk; + } + return b.value - a.value; + }); + + d3.select(containerSelector).html(""); + + const baseWidth = 1120; + const rowCount = Math.max(1, processedData.length); + const rowStep = Math.max(42, Math.min(58, 480 / rowCount)); + const rowH = Math.max(34, Math.min(48, rowStep * 0.78)); + const plotTop = 46; + const baseHeight = Math.max(620, plotTop + rowStep * rowCount + 92); + + const width = variables.width && variables.width > 700 ? variables.width : baseWidth; + const scale = width / baseWidth; + const height = Math.round(baseHeight * scale); + const vbH = baseHeight; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${baseWidth} ${vbH}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const uid = `horizontal_bar_0_${Math.random().toString(36).slice(2, 9)}`; + const defs = svg.append("defs"); + const bgGradient = defs.append("linearGradient") + .attr("id", `${uid}_bg`) + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "100%").attr("y2", "100%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ffffff"); + bgGradient.append("stop").attr("offset", "62%").attr("stop-color", "#f7fbff"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#d9ecf8"); + + const barGradient = defs.append("linearGradient") + .attr("id", `${uid}_bar`) + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "100%").attr("y2", "0%"); + barGradient.append("stop").attr("offset", "0%").attr("stop-color", "#0a55ad"); + barGradient.append("stop").attr("offset", "58%").attr("stop-color", "#126ec6"); + barGradient.append("stop").attr("offset", "100%").attr("stop-color", "#43a9f3"); + + const softShadow = defs.append("filter") + .attr("id", `${uid}_soft_shadow`) + .attr("x", "-12%").attr("y", "-24%") + .attr("width", "124%").attr("height", "148%"); + softShadow.append("feDropShadow") + .attr("dx", 0).attr("dy", 4) + .attr("stdDeviation", 5) + .attr("flood-color", "#16456e") + .attr("flood-opacity", 0.11); + + svg.append("rect") + .attr("class", "reference-canvas") + .attr("x", 0).attr("y", 0) + .attr("width", baseWidth).attr("height", vbH) + .attr("rx", 24).attr("fill", `url(#${uid}_bg)`) + .attr("stroke", "rgba(32,70,105,0.18)"); + + const chart = { + x: 26, + y: 30, + w: 714, + h: vbH - 58 + }; + const right = { + x: 770, + y: 52, + w: 310, + h: vbH - 96 + }; + const iconX = chart.x + 44; + const labelX = chart.x + 92; + const barX = chart.x + 304; + const valueTexts = processedData.map(d => formatValue(d.value)); + const maxValueTextLen = d3.max(valueTexts, d => d.length) || 0; + const valueFontPx = rowCount > 12 ? 14 : (maxValueTextLen > 10 ? 15 : 18); + const valueColumnW = Math.min(210, Math.max(60, Math.ceil(maxValueTextLen * valueFontPx * 0.66))); + const valueRightX = right.x - 22; + const barW = Math.max(150, valueRightX - valueColumnW - 12 - barX); + + svg.append("rect") + .attr("class", "reference-chart-card") + .attr("x", chart.x).attr("y", chart.y) + .attr("width", chart.w).attr("height", chart.h) + .attr("rx", 18) + .attr("fill", "rgba(255,255,255,0.74)") + .attr("stroke", "rgba(30,82,125,0.10)") + .style("filter", `url(#${uid}_soft_shadow)`); + + const maxValue = d3.max(processedData, d => d.value) || 1; + const xScale = d3.scaleLinear() + .domain([0, Math.max(maxValue, 1)]) + .range([0, barW]); + + function formatValue(v) { + const base = chartUtils.format.autoText(v); + return `${base}${yUnit ? yUnit : ""}`; + } + + function splitLabel(label) { + const match = String(label).match(/^(.*?)\s*\(([^)]*)\)\s*$/); + const primaryText = match ? match[1].trim() : String(label).trim(); + const suffix = match ? `(${match[2].trim()})` : ""; + const words = primaryText.split(/\s+/).filter(Boolean); + if (primaryText.length > 19 && words.length > 1) { + let first = ""; + const rest = []; + words.forEach(word => { + const trial = first ? `${first} ${word}` : word; + if (!first || trial.length <= 18) { + first = trial; + } else { + rest.push(word); + } + }); + const second = [rest.join(" "), suffix].filter(Boolean).join(" ").trim(); + return [first, second]; + } + return [primaryText, suffix]; + } + + function wrapTextLines(text, maxChars, maxLines) { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const next = current ? `${current} ${word}` : word; + if (next.length > maxChars && current) { + lines.push(current); + current = word; + } else { + current = next; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = `${kept[maxLines - 1].replace(/\.*$/, "")}...`; + return kept; + } + return lines; + } + + const rowsG = svg.append("g") + .attr("class", "reference-horizontal-bar-list") + .attr("data-field-x", xField) + .attr("data-field-y", yField); + + processedData.forEach((d, i) => { + const cy = plotTop + i * rowStep + rowH / 2; + const rowY = cy - rowH / 2; + const row = rowsG.append("g") + .attr("class", "reference-bar-row") + .attr("data-source-index", d.sourceIndex) + .attr("data-category", d.category) + .attr("data-value", d.value) + .attr("data-display-value", formatValue(d.value)) + .attr("data-rank", i + 1); + + row.append("rect") + .attr("class", "reference-row-card") + .attr("x", chart.x + 20) + .attr("y", rowY) + .attr("width", chart.w - 46) + .attr("height", rowH) + .attr("rx", rowH / 2) + .attr("fill", "#ffffff") + .attr("stroke", "rgba(49,97,142,0.08)") + .style("filter", `url(#${uid}_soft_shadow)`); + + const slotR = Math.min(22, rowH * 0.46); + const slot = row.append("g") + .attr("class", "reference-row-icon-slot reserved-asset-slot") + .attr("data-asset-slot", "row-category-icon") + .attr("data-reserved-slot", "row-category-icon") + .attr("data-bbox", `${iconX - slotR},${cy - slotR},${slotR * 2},${slotR * 2}`) + .attr("data-anchor", `row-center:${d.category}`) + .attr("data-collision-rule", "row icon slot must avoid category label, bar, value label, and canvas edge") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-asset-source-policy", "image2_asset") + .attr("transform", `translate(${iconX},${cy})`); + + slot.append("circle") + .attr("r", slotR) + .attr("fill", "#f7fbff") + .attr("stroke", "#1f80dc") + .attr("stroke-width", 2.2); + slot.append("circle") + .attr("r", slotR * 0.68) + .attr("fill", "rgba(31,128,220,0.10)") + .attr("stroke", "rgba(31,128,220,0.18)"); + slot.append("text") + .attr("class", "row-rank-neutral-marker") + .attr("x", 0).attr("y", 4) + .attr("text-anchor", "middle") + .style("font-family", typography.label?.font_family || "Arial") + .style("font-size", "10px") + .style("font-weight", 800) + .style("fill", "#0b52ab") + .text(i + 1); + + const [primary, secondary] = splitLabel(d.category); + const labelFont = rowCount > 12 ? 13 : 15; + row.append("text") + .attr("class", "category-label") + .attr("x", labelX) + .attr("y", secondary ? cy - 3 : cy + 5) + .attr("fill", "#092d5c") + .style("font-family", typography.label?.font_family || "Arial") + .style("font-size", `${labelFont}px`) + .style("font-weight", 800) + .text(primary); + if (secondary) { + row.append("text") + .attr("class", "category-label-secondary") + .attr("x", labelX) + .attr("y", cy + 13) + .attr("fill", "#64748b") + .style("font-family", typography.label?.font_family || "Arial") + .style("font-size", `${Math.max(10, labelFont - 2)}px`) + .style("font-weight", 600) + .text(secondary); + } + + const barH = Math.max(16, Math.min(26, rowH * 0.54)); + const barY = cy - barH / 2; + row.append("rect") + .attr("class", "bar mark") + .attr("data-source-index", d.sourceIndex) + .attr("data-category", d.category) + .attr("data-value", d.value) + .attr("data-endcap-shape", "rounded-pill") + .attr("x", barX) + .attr("y", barY) + .attr("width", Math.max(barH, xScale(d.value))) + .attr("height", barH) + .attr("rx", barH / 2) + .attr("fill", `url(#${uid}_bar)`); + + row.append("text") + .attr("class", "value-label") + .attr("data-source-index", d.sourceIndex) + .attr("data-category", d.category) + .attr("data-value", d.value) + .attr("x", valueRightX) + .attr("y", cy + 6) + .attr("text-anchor", "end") + .attr("fill", "#0a438a") + .style("font-family", typography.label?.font_family || "Arial") + .style("font-size", `${valueFontPx}px`) + .style("font-weight", 900) + .text(formatValue(d.value)); + }); + + const rightG = svg.append("g") + .attr("class", "reference-right-panel") + .attr("data-anchor", "right-safe-column") + .attr("data-collision-rule", "independent right panel avoids chart rows and value labels"); + + const heroSlot = rightG.append("g") + .attr("class", "right-hero-illustration-slot reserved-asset-slot") + .attr("data-asset-slot", "right-hero-illustration") + .attr("data-reserved-slot", "right-hero-illustration") + .attr("data-bbox", `${right.x + 28},${right.y},${right.w - 56},170`) + .attr("data-anchor", "right-panel-top") + .attr("data-collision-rule", "hero slot must stay above title and away from chart rows") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-asset-source-policy", "image2_asset"); + heroSlot.append("circle") + .attr("cx", right.x + right.w / 2) + .attr("cy", right.y + 86) + .attr("r", 78) + .attr("fill", "#d7ebfb"); + heroSlot.append("rect") + .attr("x", right.x + 70) + .attr("y", right.y + 54) + .attr("width", 170) + .attr("height", 92) + .attr("rx", 18) + .attr("fill", "rgba(255,255,255,0.54)") + .attr("stroke", "rgba(16,103,183,0.15)"); + heroSlot.append("line") + .attr("x1", right.x + 92).attr("x2", right.x + 218) + .attr("y1", right.y + 126).attr("y2", right.y + 82) + .attr("stroke", "rgba(10,67,138,0.42)") + .attr("stroke-width", 10) + .attr("stroke-linecap", "round"); + + const rawTitle = String(titles.main_title || metadata.title || `${yField} by ${xField}`).trim(); + const titleWords = rawTitle.replace(/\bby\b/ig, "by").split(/\s+/); + const byIndex = titleWords.findIndex(w => w.toLowerCase() === "by"); + const titleMain = byIndex > 0 ? titleWords.slice(0, byIndex).join(" ") : rawTitle; + const titleSub = byIndex > 0 ? titleWords.slice(byIndex).join(" ") : ""; + const titleLines = wrapTextLines(titleMain.toUpperCase(), 16, 3); + let titleY = right.y + 252; + titleLines.forEach((line, i) => { + rightG.append("text") + .attr("class", "reference-title") + .attr("x", right.x + right.w / 2) + .attr("y", titleY + i * 34) + .attr("text-anchor", "middle") + .style("font-family", typography.title?.font_family || "Arial") + .style("font-size", "30px") + .style("font-weight", 900) + .style("letter-spacing", "1.2px") + .style("fill", "#072b5e") + .text(line); + }); + const subY = titleY + titleLines.length * 34 + 2; + rightG.append("text") + .attr("class", "reference-title-subline") + .attr("x", right.x + right.w / 2) + .attr("y", subY) + .attr("text-anchor", "middle") + .style("font-family", typography.title?.font_family || "Arial") + .style("font-size", "24px") + .style("font-weight", 800) + .style("fill", "#2b83d8") + .text(titleSub || String(xField || "")); + + const dividerY = subY + 42; + rightG.append("line") + .attr("x1", right.x + 56).attr("x2", right.x + 132) + .attr("y1", dividerY).attr("y2", dividerY) + .attr("stroke", "#b7ccdd").attr("stroke-width", 1.5); + rightG.append("line") + .attr("x1", right.x + right.w - 132).attr("x2", right.x + right.w - 56) + .attr("y1", dividerY).attr("y2", dividerY) + .attr("stroke", "#b7ccdd").attr("stroke-width", 1.5); + const dividerSlot = rightG.append("g") + .attr("class", "title-divider-icon-slot reserved-asset-slot") + .attr("data-asset-slot", "title-divider-icon") + .attr("data-reserved-slot", "title-divider-icon") + .attr("data-bbox", `${right.x + right.w / 2 - 16},${dividerY - 16},32,32`) + .attr("data-anchor", "right-panel-title-divider") + .attr("data-collision-rule", "small divider slot avoids title and description text") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-asset-source-policy", "image2_asset") + .attr("transform", `translate(${right.x + right.w / 2},${dividerY})`); + dividerSlot.append("circle") + .attr("r", 12) + .attr("fill", "rgba(11,82,171,0.10)") + .attr("stroke", "rgba(11,82,171,0.22)"); + + const description = String(titles.sub_title || metadata.description || metadata.main_insight || "").replace(/\*\*/g, ""); + const descLines = wrapTextLines(description, 32, 4); + descLines.forEach((line, i) => { + rightG.append("text") + .attr("class", "reference-description") + .attr("x", right.x + right.w / 2) + .attr("y", dividerY + 56 + i * 23) + .attr("text-anchor", "middle") + .style("font-family", typography.description?.font_family || "Arial") + .style("font-size", "15px") + .style("font-weight", i === descLines.length - 1 ? 700 : 500) + .style("fill", i === descLines.length - 1 ? "#47753b" : "#53687d") + .text(line); + }); + + const landscape = svg.append("g") + .attr("class", "bottom-landscape-decoration-slot reserved-asset-slot") + .attr("data-asset-slot", "bottom-landscape-decoration") + .attr("data-reserved-slot", "bottom-landscape-decoration") + .attr("data-bbox", `${baseWidth * 0.56},${vbH - 84},${baseWidth * 0.40},72`) + .attr("data-anchor", "bottom-right-background") + .attr("data-collision-rule", "background slot must stay behind bars, value labels, and right-panel text") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-asset-source-policy", "image2_asset") + .attr("opacity", 0.34); + const hill = d3.area() + .x(d => d[0]) + .y0(vbH) + .y1(d => d[1]) + .curve(d3.curveBasis); + landscape.append("path") + .attr("d", hill([[baseWidth * 0.54, vbH - 10], [baseWidth * 0.64, vbH - 31], [baseWidth * 0.74, vbH - 24], [baseWidth * 0.84, vbH - 52], [baseWidth * 0.98, vbH - 43]])) + .attr("fill", "#bcd7ec"); + [0.66, 0.72, 0.88, 0.94].forEach((t, i) => { + const x = baseWidth * t; + const y = vbH - 18 - i * 7; + landscape.append("path") + .attr("d", `M${x},${y} l11,0 l-9,-12 l7,0 l-8,-14 l6,0 l-8,-16 l-8,16 l6,0 l-8,14 l7,0 l-9,12 l11,0 Z`) + .attr("fill", "#95b9d5"); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_test.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_test.js new file mode 100644 index 0000000000000000000000000000000000000000..0350020338a61a0ef03f5796ec5b75d6f8ffa41a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_test.js @@ -0,0 +1,369 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_test", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["gradient", "stroke", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // Block 1: Configuration & Data Extraction + // --------------------------------------------------------------------- + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = { + title: { font_family: "Arial", font_size: "28px", font_weight: 700, ...((jsonData.typography || {}).title || {}) }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500, ...((jsonData.typography || {}).label || {}) }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500, ...((jsonData.typography || {}).description || {}) }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400, ...((jsonData.typography || {}).annotation || {}) } + }; + const colors = { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341", secondary: "#83C341", ...(jsonData.colors || {}).other }, + ...(jsonData.colors || {}) + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // Removed default fallback strings for field names and column titles + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key; + + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : (chartUtils.schema.channel(jsonData, "y").unit || ""); + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : (chartUtils.schema.channel(jsonData, "y2").unit || ""); + + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key; + + // Early exit or error if critical fields are not defined (optional, but good practice) + if (!dimensionField || !valueField1 || !valueField2) { + console.error("Critical data fields (dimensionField, valueField1, or valueField2) are not defined in dataColumns. Cannot render chart."); + d3.select(containerSelector).html("

Error: Chart configuration incomplete. Required data fields missing.

"); + return null; // Or throw new Error(...) + } + + + // Block 2: SVG Container Setup + // --------------------------------------------------------------------- + d3.select(containerSelector).html(""); + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", variables.height || 600) + .attr("viewBox", `0 0 ${variables.width || 800} ${variables.height || 600}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // Block 3: Global Utilities & Helper Functions + // --------------------------------------------------------------------- + const tempTextMeasureGroup = svg.append("g").attr("visibility", "hidden").attr("id", "tempTextMeasureGroup"); + + const estimateTextWidth = (text, fontConfig, dynamicFontSize = null) => chartUtils.text.measure(tempTextMeasureGroup, text, { + fontFamily: fontConfig.font_family, + fontSize: dynamicFontSize || fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + + function getWrappedTextLines(textContent, availableWidth, fontConfig) { + const words = (textContent || "").trim().split(/\s+/).filter(w => w !== ""); // Handles undefined textContent gracefully + const lines = []; + const fontSizeValue = parseFloat(fontConfig.font_size); + const lineHeight = fontSizeValue * 1.2; + + if (words.length === 0) return { linesArray: [], numLines: 0, lineHeight: lineHeight }; + + const breakSingleWord = (word) => { + let currentWordPart = ""; + const wordLines = []; + for (let char of word) { + if (estimateTextWidth(currentWordPart + char, fontConfig) > availableWidth && currentWordPart !== "") { + wordLines.push(currentWordPart); + currentWordPart = char; + } else { + currentWordPart += char; + } + } + if (currentWordPart !== "") wordLines.push(currentWordPart); + return wordLines.length > 0 ? wordLines : [word]; + }; + + if (words.length === 1) { + lines.push(...(estimateTextWidth(words[0], fontConfig) > availableWidth ? breakSingleWord(words[0]) : [words[0]])); + return { linesArray: lines.filter(l => l), numLines: lines.filter(l => l).length, lineHeight: lineHeight }; + } + + let currentLine = words[0]; + if (estimateTextWidth(currentLine, fontConfig) > availableWidth) { + const brokenFirstWord = breakSingleWord(currentLine); + lines.push(...brokenFirstWord.slice(0, -1)); + currentLine = brokenFirstWord.length > 0 ? brokenFirstWord[brokenFirstWord.length - 1] : ""; + } + + for (let i = 1; i < words.length; i++) { + const word = words[i]; + if (estimateTextWidth(word, fontConfig) > availableWidth) { + if (currentLine !== "") lines.push(currentLine); + lines.push(...breakSingleWord(word)); + currentLine = ""; + continue; + } + const testLine = currentLine === "" ? word : currentLine + " " + word; + if (estimateTextWidth(testLine, fontConfig) > availableWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + if (currentLine !== "") { + lines.push(...(estimateTextWidth(currentLine, fontConfig) > availableWidth ? breakSingleWord(currentLine) : [currentLine])); + } + return { linesArray: lines.filter(l => l), numLines: lines.filter(l => l).length, lineHeight: lineHeight }; + } + + + const getPrimaryColor = (variation = "default") => { + const base = colorResolver.other("primary").value; + if (variation === "darker") return colorResolver.variant(base, { mode: "darker", amount: 0.3 }).toString(); + if (variation === "brighter") return colorResolver.variant(base, { mode: "brighter", amount: 0.5 }).toString(); + if (variation === "stroke") return colorResolver.variant(base, { mode: "brighter", amount: 3 }).toString(); + return base; + }; + const getSecondaryColor = () => colorResolver.other("secondary").value; + + // Block 4: Core Chart Dimensions & Layout Calculation + // --------------------------------------------------------------------- + const width = variables.width || 800; + const height = variables.height || 600; + const flagWidth = 30; + const flagHeight = 30; + const textPadding = 5; + const minFontSize = 8; + const defaultLabelFontSize = parseFloat(typography.label.font_size); + + let maxDimLabelWidth = 0; + chartData.forEach(d => { + // Ensure d[dimensionField] is treated as a string for consistent measurement + maxDimLabelWidth = Math.max(maxDimLabelWidth, estimateTextWidth(String(d[dimensionField] || "").toUpperCase(), typography.label)); + }); + + const maxAllowedLabelSpace = width * 0.15; + let finalDimLabelFontSize = defaultLabelFontSize; + if (maxDimLabelWidth > maxAllowedLabelSpace) { + const scaleFactor = maxAllowedLabelSpace / maxDimLabelWidth; + finalDimLabelFontSize = Math.max(minFontSize, defaultLabelFontSize * scaleFactor); + maxDimLabelWidth = 0; + chartData.forEach(d => { + maxDimLabelWidth = Math.max(maxDimLabelWidth, estimateTextWidth(String(d[dimensionField] || "").toUpperCase(), typography.label, `${finalDimLabelFontSize}px`)); + }); + } + + const margin = { + top: 100, + right: 5, + bottom: 40, + left: maxDimLabelWidth + textPadding + flagWidth + textPadding + 5 + }; + + const leftColumnRatio = 0.85; + const rightColumnRatio = 0.15; + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + const barChartWidth = innerWidth * leftColumnRatio; + const circleChartWidth = innerWidth * rightColumnRatio; + + // Block 5: Data Preprocessing + // --------------------------------------------------------------------- + const sortedData = [...chartData].sort((a, b) => (b[valueField1] || 0) - (a[valueField1] || 0)); // Added fallback for sorting + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // Block 6: Scale Definition + // --------------------------------------------------------------------- + const barPadding = 0.2; + const yScale = d3.scaleBand() + .domain(sortedDimensions) // If dimensionField was undefined, sortedDimensions might be array of undefineds + .range([0, innerHeight]) + .padding(barPadding); + + const xScale = d3.scaleLinear() + // Added fallback for max calculation in case valueField1 is missing or data is malformed + .domain([0, d3.max(sortedData, d => +(d[valueField1] || 0)) * 1.05 || 1]) // Ensure domain is valid + .range([0, barChartWidth]); + + const maxValue2 = d3.max(sortedData, d => +(d[valueField2] || 0)); + const minRadius = yScale.bandwidth() * 0.3; // yScale.bandwidth() could be 0 if sortedDimensions is empty + const maxRadius = Math.min(yScale.bandwidth() * 1.0 || 20, circleChartWidth * 0.5 || 20); // Added fallback for bandwidth + const radiusScale = d3.scaleSqrt() + .domain([0, maxValue2 || 0]) + .range([minRadius || 5, maxRadius || 20]); // Added fallback for radii + + // Block 7: SVG Definitions (Defs) - Gradients, Filters, Patterns + // --------------------------------------------------------------------- + const defs = svg.append("defs"); + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%").attr("y1", "0%").attr("x2", "100%").attr("y2", "0%"); + gradient.append("stop").attr("offset", "0%").attr("stop-color", getPrimaryColor("darker")); + gradient.append("stop").attr("offset", "100%").attr("stop-color", getPrimaryColor("brighter")); + + // Block 8: Drawing Chart Titles & Headers (Column Titles) + // --------------------------------------------------------------------- + // columnTitle1 and columnTitle2 might be undefined. getWrappedTextLines handles this. + const titleFontConfig = typography.description; + const titleBottomPadding = 5; + const desiredBaselineOfLastLine = margin.top - titleBottomPadding; + + const leftTitleAvailableWidth = innerWidth * 0.6; + const leftTitleXPos = margin.left; + const wrappedLeftTitle = getWrappedTextLines(columnTitle1, leftTitleAvailableWidth, titleFontConfig); + if (wrappedLeftTitle.numLines > 0) { + const initialYLeft = desiredBaselineOfLastLine - (wrappedLeftTitle.numLines - 1) * wrappedLeftTitle.lineHeight; + const leftTitleText = svg.append("text") + .attr("x", leftTitleXPos).attr("y", initialYLeft) + .attr("text-anchor", "start") + .style("font-family", titleFontConfig.font_family).style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight).style("fill", colorResolver.text({ fallback: "#333333" }).value); + wrappedLeftTitle.linesArray.forEach((line, i) => { + leftTitleText.append("tspan").attr("x", leftTitleXPos).attr("dy", i === 0 ? 0 : wrappedLeftTitle.lineHeight).text(line); + }); + } + + const rightTitleAvailableWidth = innerWidth * 0.4; + const rightTitleXPos = margin.left + innerWidth; + const wrappedRightTitle = getWrappedTextLines(columnTitle2, rightTitleAvailableWidth, titleFontConfig); + if (wrappedRightTitle.numLines > 0) { + const initialYRight = desiredBaselineOfLastLine - (wrappedRightTitle.numLines - 1) * wrappedRightTitle.lineHeight; + const rightTitleText = svg.append("text") + .attr("x", rightTitleXPos).attr("y", initialYRight) + .attr("text-anchor", "end") + .style("font-family", titleFontConfig.font_family).style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight).style("fill", colorResolver.text({ fallback: "#333333" }).value); + wrappedRightTitle.linesArray.forEach((line, i) => { + rightTitleText.append("tspan").attr("x", rightTitleXPos).attr("dy", i === 0 ? 0 : wrappedRightTitle.lineHeight).text(line); + }); + } + + // Block 9: Main Chart Rendering Loop + // --------------------------------------------------------------------- + const g = svg.append("g").attr("transform", `translate(${margin.left}, ${margin.top})`); + + sortedData.forEach((dataPoint, index) => { + const dimension = dataPoint[dimensionField]; // Might be undefined if dimensionField was not found + + const barHeight = yScale.bandwidth(); // Might be 0 or NaN if domain was empty/problematic + const y = yScale(dimension); + + // If y is undefined, centerY will be NaN. Operations using it will likely fail silently for SVG. + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+(dataPoint[valueField1] || 0))); // Added fallback + + // --- Dimension Label & Icon --- + const dimLabelX = -(flagWidth + textPadding + 5); + const iconX = -flagWidth - 5; + + g.append("text") + .attr("x", dimLabelX).attr("y", centerY).attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family).style("font-size", `${finalDimLabelFontSize}px`) + .style("font-weight", typography.label.font_weight).style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(String(dimension || "").toUpperCase()); // Handle undefined dimension for text + + const iconGroup = g.append("g").attr("transform", `translate(${iconX}, ${centerY - flagHeight / 2})`); + // Ensure dimension is a string for image key lookup, or provide a fallback + const imageKey = String(dimension || `__undefined_key_${index}__`); + if (images.field && images.field[imageKey]) { + iconGroup.append("image") + .attr("x", 0).attr("y", 0).attr("width", flagWidth).attr("height", flagHeight) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[imageKey]); + } else { + iconGroup.append("rect") + .attr("x", 0).attr("y", 0).attr("width", flagWidth).attr("height", flagHeight) + .attr("fill", getPrimaryColor("stroke")).attr("opacity", 0.3); + } + + // --- Bar Element --- + if (typeof y === 'number' && barHeight > 0) { // Add check to prevent drawing if y or barHeight is invalid + g.append("rect") + .attr("x", 0).attr("y", y) + .attr("width", barWidthValue).attr("height", barHeight) + .attr("fill", "url(#bar-gradient)") + .attr("rx", barHeight / 4).attr("ry", barHeight / 4) + .attr("opacity", 0.9); + + // --- Bar Value Label --- + const valueLabelText1 = `${chartUtils.format.scaledText(+(dataPoint[valueField1] || 0))}${valueUnit1}`; // Added fallback + const dynamicValueLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const currentBarValueLabelWidth = estimateTextWidth(valueLabelText1, typography.annotation, dynamicValueLabelFontSize); + + let valueLabel1XPos, valueLabel1Anchor, valueLabel1Fill; + const internalPadding = 10; const externalPadding = 5; + if (barWidthValue >= currentBarValueLabelWidth + internalPadding * 2) { + valueLabel1XPos = internalPadding; valueLabel1Anchor = "start"; valueLabel1Fill = "#FFFFFF"; + } else { + valueLabel1XPos = barWidthValue + externalPadding; valueLabel1Anchor = "start"; valueLabel1Fill = colorResolver.text({ fallback: "#333333" }).value; + } + g.append("text") + .attr("x", valueLabel1XPos).attr("y", centerY).attr("dy", "0.35em") + .attr("text-anchor", valueLabel1Anchor) + .style("font-family", typography.annotation.font_family).style("font-size", dynamicValueLabelFontSize) + .style("font-weight", typography.annotation.font_weight).style("fill", valueLabel1Fill) + .text(valueLabelText1); + } + + // --- Circle Element --- + const circleRadiusValue = radiusScale(+(dataPoint[valueField2] || 0)); // Added fallback + if (typeof centerY === 'number' && typeof circleRadiusValue === 'number' && circleRadiusValue >= 0) { // Add check + g.append("circle") + .attr("cx", barChartWidth + circleChartWidth / 2).attr("cy", centerY) + .attr("r", circleRadiusValue) + .attr("fill", getSecondaryColor()) + .attr("opacity", 0.6); + + // --- Circle Value Label --- + const valueLabelText2 = `${chartUtils.format.scaledText(+(dataPoint[valueField2] || 0))}${valueUnit2}`; // Added fallback + const dynamicCircleLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6 || 10, parseFloat(typography.annotation.font_size)))}px`; // Fallback for barHeight + + g.append("text") + .attr("x", barChartWidth + circleChartWidth / 2).attr("y", centerY).attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family).style("font-size", dynamicCircleLabelFontSize) + .style("font-weight", typography.annotation.font_weight).style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(valueLabelText2); + } + }); + + // Block 10: Cleanup + // --------------------------------------------------------------------- + tempTextMeasureGroup.remove(); + + // Block 11: Return SVG Node + // --------------------------------------------------------------------- + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_weilai.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_weilai.js new file mode 100644 index 0000000000000000000000000000000000000000..9f6a85c51d17e45c53051995abaf9a9f1ff3dd40 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_0_weilai.js @@ -0,0 +1,318 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_0_weilai", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100000]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["gradient", "opacity"], + "min_height": 300, + "min_width": 300, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = jsonData.data.data; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + + d3.select(containerSelector).html(""); + + const width = Math.max(520, +(variables.width || 600)); + const height = Math.max(430, +(variables.height || 560)); + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const yChannel = chartUtils.schema.channel(jsonData, "y") || {}; + const rawUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + const displayUnit = rawUnit === "$" ? "USD" : rawUnit; + const processedData = chartData.map((d, index) => ({ + category: d[xField], + value: +d[yField], + index + })).filter(d => Number.isFinite(d.value)); + + const n = Math.max(1, processedData.length); + const cardX = 14; + const cardY = 16; + const cardW = width - cardX * 2; + const cardH = height - cardY * 2; + const plotTop = n > 7 ? 48 : 72; + const axisH = 82; + const plotBottom = cardH - axisH; + const stackedRowHeader = n <= 5; + const iconCx = cardX + (stackedRowHeader ? 62 : 44); + const iconR = n > 7 ? 12 : (stackedRowHeader ? 28 : 18); + const labelX = stackedRowHeader ? iconCx : cardX + (n > 7 ? 68 : 76); + const plotX = cardX + Math.min(235, Math.max(150, cardW * (n > 7 ? 0.34 : 0.28))); + const valuePad = n > 7 ? 52 : 68; + const plotW = Math.max(120, cardX + cardW - plotX - valuePad); + const labelMaxWidth = Math.max(60, plotX - labelX - 14); + const maxValue = d3.max(processedData, d => d.value) || 1; + + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([plotTop, plotBottom]) + .padding(n > 7 ? 0.25 : 0.38); + const xScale = d3.scaleLinear() + .domain([0, maxValue]) + .range([0, plotW]) + .nice(); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const safeId = `weilai-${Math.random().toString(36).slice(2)}`; + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", `${safeId}-card-shadow`) + .attr("x", "-8%") + .attr("y", "-8%") + .attr("width", "116%") + .attr("height", "116%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 10) + .attr("stdDeviation", 10) + .attr("flood-color", "#23415C") + .attr("flood-opacity", 0.10); + + const gridTicks = xScale.ticks(5); + const axisY = cardY + plotBottom + 28; + const plotTopAbs = cardY + plotTop; + const plotBottomAbs = cardY + plotBottom; + const plotXAbs = plotX; + + const card = svg.append("g") + .attr("class", "weilai-chart-card") + .attr("data-role", "chart-card") + .attr("data-reference-relationship", "white rounded card contains row icon slots, category labels, bars, values, and x-axis"); + + card.append("rect") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardW) + .attr("height", cardH) + .attr("rx", 14) + .attr("fill", "#FFFFFF") + .attr("stroke", "#E5EEF6") + .attr("stroke-width", 1.2) + .attr("filter", `url(#${safeId}-card-shadow)`); + + card.selectAll(".weilai-gridline") + .data(gridTicks) + .enter() + .append("line") + .attr("class", "weilai-gridline") + .attr("x1", d => plotXAbs + xScale(d)) + .attr("x2", d => plotXAbs + xScale(d)) + .attr("y1", plotTopAbs - 4) + .attr("y2", plotBottomAbs + 10) + .attr("stroke", "#EAF0F6") + .attr("stroke-width", 1); + + card.append("line") + .attr("class", "weilai-baseline") + .attr("data-reference-relationship", "flat left bar baseline flush with x-axis origin") + .attr("x1", plotXAbs) + .attr("x2", plotXAbs) + .attr("y1", plotTopAbs - 6) + .attr("y2", plotBottomAbs + 12) + .attr("stroke", "#D5E1EC") + .attr("stroke-width", 1.2); + + const row = card.selectAll(".weilai-row") + .data(processedData) + .enter() + .append("g") + .attr("class", "weilai-row") + .attr("data-category", d => d.category) + .attr("data-value", d => d.value) + .attr("transform", d => `translate(0, ${cardY + yScale(d.category) + yScale.bandwidth() / 2})`); + + row.append("circle") + .attr("class", "reserved-asset-slot weilai-row-icon-slot") + .attr("data-asset-slot", "weilai_row_icon_slot") + .attr("data-slot-policy", "retrieval_or_image2_asset") + .attr("data-asset-source-policy", "retrieval_or_image2_asset_per_category") + .attr("data-anchor", "row-center-left-of-category-label") + .attr("data-collision-rule", "stay inside chart card row header column and share row centerline with bar") + .attr("data-bbox-policy", "cx cy and r define circular icon slot bbox") + .attr("data-mask-policy", "downstream asset may replace only inside this circle") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-category", d => d.category) + .attr("cx", iconCx) + .attr("cy", 0) + .attr("r", iconR) + .attr("fill", (d, i) => i % 2 ? "#F1FBF8" : "#EEF5FF") + .attr("stroke", (d, i) => i % 2 ? "#8BD7C0" : "#BBD2F5") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "4 3"); + + row.append("circle") + .attr("class", "weilai-row-icon-neutral-anchor") + .attr("cx", iconCx) + .attr("cy", 0) + .attr("r", Math.max(2.8, iconR * 0.16)) + .attr("fill", "#0A8B72") + .attr("opacity", 0.28) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + row.append("text") + .attr("class", "weilai-category-label") + .attr("x", labelX) + .attr("y", stackedRowHeader ? iconR + 27 : (n > 7 ? -2 : -5)) + .attr("text-anchor", stackedRowHeader ? "middle" : "start") + .attr("font-family", typography.label.font_family || "Arial, Helvetica, sans-serif") + .attr("font-size", n > 7 ? 11 : (stackedRowHeader ? 16 : 14)) + .attr("font-weight", 700) + .attr("fill", "#0F2F55") + .attr("letter-spacing", 0) + .attr("textLength", d => { + const fontSize = n > 7 ? 11 : (stackedRowHeader ? 16 : 14); + const maxWidth = stackedRowHeader ? Math.max(70, iconR * 2.7) : labelMaxWidth; + return estimateTextWidth(String(d.category), fontSize) > maxWidth ? maxWidth : null; + }) + .attr("lengthAdjust", "spacingAndGlyphs") + .text(d => String(d.category)); + + row.append("path") + .attr("class", "bar weilai-bar") + .attr("data-reference-end-shape", "flat-left-baseline-rounded-right-value-edge") + .attr("data-category", d => d.category) + .attr("data-value", d => d.value) + .attr("d", d => rightRoundedBarPath(plotXAbs, -yScale.bandwidth() / 2, Math.max(2, xScale(d.value)), yScale.bandwidth(), Math.min(yScale.bandwidth() / 2, 9))) + .attr("fill", (d, i) => i === 0 ? "#0C4FC3" : (i === 1 ? "#2F78F4" : "#2B8AF5")) + .attr("opacity", 0.98); + + row.each(function(d) { + const g = d3.select(this); + const endX = plotXAbs + xScale(d.value); + const outsideX = endX + 12; + const clamped = outsideX > cardX + cardW - 38; + const valueX = clamped ? cardX + cardW - 28 : outsideX; + const anchor = clamped ? "end" : "start"; + g.append("text") + .attr("class", "weilai-value-label") + .attr("x", valueX) + .attr("y", displayUnit ? -4 : 4) + .attr("text-anchor", anchor) + .attr("font-family", typography.label.font_family || "Arial, Helvetica, sans-serif") + .attr("font-size", n > 7 ? 11 : 22) + .attr("font-weight", 800) + .attr("fill", "#0B56D0") + .attr("letter-spacing", 0) + .text(chartUtils.format.autoText(d.value)); + if (displayUnit) { + g.append("text") + .attr("class", "weilai-value-unit") + .attr("x", valueX) + .attr("y", n > 7 ? 9 : 13) + .attr("text-anchor", anchor) + .attr("font-family", typography.label.font_family || "Arial, Helvetica, sans-serif") + .attr("font-size", n > 7 ? 7 : 13) + .attr("font-weight", 700) + .attr("fill", "#7690AA") + .attr("letter-spacing", 0) + .text(displayUnit); + } + }); + + const axis = card.append("g") + .attr("class", "weilai-x-axis") + .attr("data-reference-relationship", "independent bottom axis inside chart card"); + + axis.selectAll(".weilai-tick-label") + .data(gridTicks) + .enter() + .append("text") + .attr("class", "weilai-tick-label") + .attr("x", d => plotXAbs + xScale(d)) + .attr("y", axisY) + .attr("text-anchor", "middle") + .attr("font-family", typography.label.font_family || "Arial, Helvetica, sans-serif") + .attr("font-size", n > 7 ? 8 : 10) + .attr("font-weight", 500) + .attr("fill", "#8A9BAE") + .attr("letter-spacing", 0) + .text(d => chartUtils.format.autoText(d)); + + axis.append("text") + .attr("class", "weilai-axis-title") + .attr("x", plotXAbs + plotW / 2) + .attr("y", axisY + (n > 7 ? 24 : 30)) + .attr("text-anchor", "middle") + .attr("font-family", typography.label.font_family || "Arial, Helvetica, sans-serif") + .attr("font-size", n > 7 ? 8 : 10) + .attr("font-weight", 800) + .attr("fill", "#526C86") + .attr("letter-spacing", 0) + .text(`${axisLabelBase()}${displayUnit ? ` (${displayUnit})` : ""}`.toUpperCase()); + + function rightRoundedBarPath(x, y, w, h, r) { + const radius = Math.min(r, h / 2, Math.max(0, w)); + if (w <= radius) { + return `M${x},${y} H${x + w} V${y + h} H${x} Z`; + } + return [ + `M${x},${y}`, + `H${x + w - radius}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `V${y + h - radius}`, + `Q${x + w},${y + h} ${x + w - radius},${y + h}`, + `H${x}`, + "Z" + ].join(" "); + } + + function humanize(value) { + return String(value || "Value") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/[_-]+/g, " ") + .trim(); + } + + function axisLabelBase() { + const base = humanize(yField); + if (!displayUnit) { + return base; + } + return base.replace(new RegExp(`\\s*${escapeRegExp(displayUnit)}$`, "i"), "").trim() || base; + } + + function escapeRegExp(value) { + return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&"); + } + + function estimateTextWidth(value, fontSize) { + return String(value || "").length * fontSize * 0.58; + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_1.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_1.js new file mode 100644 index 0000000000000000000000000000000000000000..4ee2cab68cddb6d2e4f3d729567e73bf60d05b65 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_1.js @@ -0,0 +1,361 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_1", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const colorResolver = chartUtils.color.resolver(jsonData); + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key || (xChannel.raw && xChannel.raw.name) || "category"; + const yField = yChannel.key || (yChannel.raw && yChannel.raw.name) || "value"; + const yUnit = yChannel.unit && yChannel.unit !== "none" ? yChannel.unit : ""; + + d3.select(containerSelector).html(""); + + const width = Math.max(760, Number(variables.width) || 600); + const validRowCount = chartData.filter(d => Number.isFinite(Number(d[yField])) && readable(d[xField])).length || 1; + const denseHeight = validRowCount > 12 ? Math.min(560, Math.max(430, validRowCount * 34)) : 390; + const height = denseHeight; + const fontFamily = (typography.label && typography.label.font_family) || "Arial, Helvetica, sans-serif"; + const textStrong = "#111E3B"; + const rose = "#D9476B"; + const roseDark = "#CC3E63"; + const roseSoft = "#F8CDD4"; + const bandFill = "#FFF2F2"; + const baselineColor = "#D8B8BC"; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("class", "horizontal-bar-chart-1-reference-grid"); + + const safeId = chartUtils.random.value(jsonData, "horizontal_bar_chart_1").toString(36).slice(2, 10); + const defs = svg.append("defs"); + const barGradientId = `hbar1-rose-gradient-${safeId}`; + defs.append("linearGradient") + .attr("id", barGradientId) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%") + .selectAll("stop") + .data([ + { offset: "0%", color: "#F6AAB8" }, + { offset: "62%", color: rose }, + { offset: "100%", color: roseDark } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + function message(text) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", "16px") + .style("fill", textStrong) + .text(text); + return svg.node(); + } + + function readable(value) { + return String(value == null ? "" : value) + .replace(/_/g, " ") + .replace(/\s+/g, " ") + .trim(); + } + + function parseTemporalRank(value) { + const text = String(value == null ? "" : value).trim(); + const lower = text.toLowerCase(); + const months = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, + sep: 9, sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, + dec: 12, december: 12 + }; + const seasons = { winter: 1, spring: 2, summer: 3, fall: 4, autumn: 4 }; + if (months[lower] != null) return months[lower]; + let match = text.match(/^(\d{1,2}):(\d{2})(?::(\d{2}))?$/); + if (match) return Number(match[1]) * 3600 + Number(match[2]) * 60 + Number(match[3] || 0); + match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^Q([1-4])\s+(-?\d{4})$/i) || text.match(/^(-?\d{4})\s+Q([1-4])$/i); + if (match && text.toUpperCase().startsWith("Q")) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + match = text.match(/^(winter|spring|summer|fall|autumn)\s+(-?\d{4})$/i); + if (match) return Number(match[2]) * 10 + seasons[match[1].toLowerCase()]; + match = text.match(/^(-?\d{4})\s+(winter|spring|summer|fall|autumn)$/i); + if (match) return Number(match[1]) * 10 + seasons[match[2].toLowerCase()]; + return NaN; + } + + function formatValue(value) { + const formatted = chartUtils.format.autoText(Number(value)); + if (!yUnit) return formatted; + if (yUnit === "%") return `${formatted}%`; + if (yUnit.startsWith("$")) return `${formatted} ${yUnit}`; + return `${formatted} ${yUnit}`; + } + + function truncate(text, maxChars) { + const value = readable(text); + if (value.length <= maxChars) return value; + return `${value.slice(0, Math.max(1, maxChars - 3)).trim()}...`; + } + + const rows = chartData + .map((d, index) => ({ + category: readable(d[xField]), + rawCategory: d[xField], + value: Number(d[yField]), + firstIndex: index + })) + .filter(d => d.category && Number.isFinite(d.value)); + + if (!rows.length) return message("No valid horizontal bar data"); + + rows.forEach(d => { + d.temporalRank = parseTemporalRank(d.rawCategory); + }); + const rawColumn = xChannel.raw || {}; + const allTemporal = rawColumn.data_type === "temporal" || rows.every(d => Number.isFinite(d.temporalRank)); + rows.sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.value, b.value) || d3.ascending(a.firstIndex, b.firstIndex); + }); + + const maxValue = Math.max(0, d3.max(rows, d => d.value) || 0); + const rowCount = rows.length; + const top = 12; + const bottom = 24; + const rowGap = rowCount > 12 ? 3 : 5; + const availableH = height - top - bottom; + const rowStep = availableH / rowCount; + const bandH = Math.max(24, Math.min(rowStep - rowGap, 38)); + const barH = Math.max(16, Math.min(bandH * 0.62, 26)); + const iconR = Math.max(9, Math.min(bandH * 0.31, 18)); + const iconX = width * 0.058; + const labelX = width * 0.115; + const baselineX = width * 0.318; + const valueReserve = Math.max(76, width * 0.11); + const rightSafeStart = width * 0.805; + const barMaxW = Math.max(120, rightSafeStart - baselineX - valueReserve); + const labelMaxWidth = Math.max(86, baselineX - labelX - 18); + const labelFont = Math.max(11, Math.min(16, rowStep * 0.34)); + const valueFont = Math.max(12, Math.min(18, rowStep * 0.38)); + + svg.append("rect") + .attr("class", "chart-local-bg") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "transparent"); + + const slotX = width * 0.735; + const slotY = Math.max(top + rowStep * 2.35, height * 0.32); + const slotW = width - slotX - 24; + const slotH = height - slotY - 8; + const slot = svg.append("g") + .attr("class", "reserved-asset-slot hbar1-right-growth-illustration-slot") + .attr("data-asset-slot", "right-growth-illustration") + .attr("data-reserved-slot", "right_growth_illustration_slot") + .attr("data-slot-policy", "image2_asset") + .attr("data-anchor", "right-chart-safe-area-below-header-callout") + .attr("data-collision-rule", "avoid bars value-labels category-labels title subtitle and header-callout") + .attr("data-bbox", `${slotX.toFixed(1)},${slotY.toFixed(1)},${slotW.toFixed(1)},${slotH.toFixed(1)}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("rect") + .attr("class", "reserved-slot-bbox") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 28) + .attr("fill", "#F8D7DD") + .attr("opacity", 0.18) + .attr("stroke", "#E78EA1") + .attr("stroke-width", 1.1) + .attr("stroke-dasharray", "5 7"); + slot.append("circle") + .attr("class", "reserved-slot-anchor") + .attr("cx", slotX + slotW * 0.64) + .attr("cy", slotY + slotH * 0.52) + .attr("r", Math.max(8, Math.min(18, slotW * 0.08))) + .attr("fill", rose) + .attr("opacity", 0.16); + slot.append("path") + .attr("class", "reserved-slot-mask-hint") + .attr("d", `M${slotX + slotW * 0.16},${slotY + slotH * 0.64} L${slotX + slotW * 0.44},${slotY + slotH * 0.34} L${slotX + slotW * 0.64},${slotY + slotH * 0.46} L${slotX + slotW * 0.86},${slotY + slotH * 0.17}`) + .attr("fill", "none") + .attr("stroke", "#F5BE49") + .attr("stroke-width", Math.max(2.5, width * 0.008)) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round") + .attr("opacity", 0.32); + + svg.append("line") + .attr("class", "bar-origin-baseline") + .attr("x1", baselineX) + .attr("x2", baselineX) + .attr("y1", top + rowStep * 0.08) + .attr("y2", height - bottom - rowStep * 0.08) + .attr("stroke", baselineColor) + .attr("stroke-width", 1.1); + + const row = svg.selectAll(".hbar1-row") + .data(rows) + .enter() + .append("g") + .attr("class", "hbar1-row") + .attr("data-category", d => d.category) + .attr("data-value", d => d.value) + .attr("transform", (d, i) => `translate(0, ${top + i * rowStep})`); + + row.append("rect") + .attr("class", "row-band") + .attr("x", Math.max(8, iconX - iconR - 5)) + .attr("y", (rowStep - bandH) / 2) + .attr("width", Math.max(70, rightSafeStart - Math.max(8, iconX - iconR - 5))) + .attr("height", bandH) + .attr("rx", bandH / 2) + .attr("fill", bandFill) + .attr("opacity", (d, i) => i % 2 === 0 ? 0.74 : 0.58); + + const icon = row.append("g") + .attr("class", "reserved-asset-slot hbar1-platform-icon-slot") + .attr("data-asset-slot", "platform-icon") + .attr("data-reserved-slot", d => `platform_icon_slot_${d.category.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "") || "category"}`) + .attr("data-slot-policy", "image2_asset") + .attr("data-anchor", "row-centerline") + .attr("data-collision-rule", "inside label column; avoid category labels baseline and bars") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bbox", () => `${(iconX - iconR).toFixed(1)},${((rowStep - iconR * 2) / 2).toFixed(1)},${(iconR * 2).toFixed(1)},${(iconR * 2).toFixed(1)}`); + + icon.append("circle") + .attr("class", "platform-icon-slot-ring") + .attr("cx", iconX) + .attr("cy", rowStep / 2) + .attr("r", iconR) + .attr("fill", "#FFFFFF") + .attr("stroke", "#F1B6C1") + .attr("stroke-width", 1.5); + + icon.append("circle") + .attr("class", "platform-icon-neutral-placeholder") + .attr("cx", iconX) + .attr("cy", rowStep / 2) + .attr("r", iconR * 0.72) + .attr("fill", (d, i) => d3.interpolateRgb(rose, "#4BA3E3")(Math.min(0.82, i / Math.max(1, rowCount - 1)))) + .attr("opacity", 0.24); + + icon.append("text") + .attr("x", iconX) + .attr("y", rowStep / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", `${Math.max(8, iconR * 0.62)}px`) + .style("font-weight", "800") + .style("fill", "#FFFFFF") + .style("opacity", 0.72) + .text(d => d.category.charAt(0).toUpperCase()); + + row.append("text") + .attr("class", "category-label") + .attr("x", labelX) + .attr("y", rowStep / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", fontFamily) + .style("font-size", `${labelFont}px`) + .style("font-weight", "800") + .style("fill", textStrong) + .attr("textLength", d => { + const estimated = d.category.length * labelFont * 0.56; + return estimated > labelMaxWidth ? labelMaxWidth : null; + }) + .attr("lengthAdjust", d => { + const estimated = d.category.length * labelFont * 0.56; + return estimated > labelMaxWidth ? "spacingAndGlyphs" : null; + }) + .text(d => d.category); + + row.append("rect") + .attr("class", "bar") + .attr("x", baselineX + 4) + .attr("y", (rowStep - barH) / 2) + .attr("height", barH) + .attr("width", d => Math.max(barH, (maxValue > 0 ? d.value / maxValue : 0) * barMaxW)) + .attr("rx", barH / 2) + .attr("ry", barH / 2) + .attr("fill", `url(#${barGradientId})`) + .attr("opacity", (d, i) => Math.max(0.42, 1 - i * 0.055)); + + row.append("text") + .attr("class", "value-label") + .attr("x", d => Math.min(width - 22, baselineX + 4 + Math.max(barH, (maxValue > 0 ? d.value / maxValue : 0) * barMaxW) + 14)) + .attr("y", rowStep / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", fontFamily) + .style("font-size", `${valueFont}px`) + .style("font-weight", "900") + .style("fill", roseDark) + .text(d => formatValue(d.value)); + + const dots = svg.append("g") + .attr("class", "hbar1-decorative-dot-grid") + .attr("aria-hidden", "true") + .attr("opacity", 0.42); + const dotStartX = width - 52; + const dotStartY = Math.max(28, height * 0.18); + d3.range(0, 6).forEach(col => { + d3.range(0, 6).forEach(r => { + dots.append("circle") + .attr("cx", dotStartX + col * 8) + .attr("cy", dotStartY + r * 8) + .attr("r", 1.1) + .attr("fill", roseSoft); + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..adbb956652aa719b6e2ae9ce0dfb46eb12384489 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_10.js @@ -0,0 +1,859 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_10", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 3. 数据处理 ---------- + + const rawData = [...chartData].map((d, i) => ({ ...d, __originalIndex: i })); + const dimensionValues = rawData.map(d => d[dimensionField]); + + const parseMonth = (value) => { + const text = String(value || "").trim().toLowerCase(); + const monthNames = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, + apr: 4, april: 4, may: 5, jun: 6, june: 6, jul: 7, july: 7, + aug: 8, august: 8, sep: 9, sept: 9, september: 9, + oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + return monthNames[text] || null; + }; + + const parseSeason = (value) => { + const text = String(value || "").trim().toLowerCase(); + const seasons = { spring: 1, summer: 2, fall: 3, autumn: 3, winter: 4 }; + return seasons[text] || null; + }; + + const temporalKey = (value) => { + const text = String(value || "").trim(); + const timeMatch = text.match(/^(\d{1,2}):(\d{2})(?:\s*(AM|PM))?$/i); + if (timeMatch) { + let hour = +timeMatch[1]; + const minute = +timeMatch[2]; + const period = timeMatch[3] ? timeMatch[3].toUpperCase() : null; + if (period === "PM" && hour < 12) hour += 12; + if (period === "AM" && hour === 12) hour = 0; + return hour * 60 + minute; + } + + const yearMatch = text.match(/^(?:FY|CY)?\s*(\d{4})$/i); + if (yearMatch) return +yearMatch[1] * 10000; + + const semesterMatch = text.match(/^(?:semester|sem)\s*(\d+)\s*(?:[- ]?(\d{4}))?$/i); + if (semesterMatch) { + const year = semesterMatch[2] ? +semesterMatch[2] : 0; + return year * 10 + +semesterMatch[1]; + } + + const quarterMatch = text.match(/^(?:Q([1-4])\s*(\d{4})|(\d{4})\s*Q([1-4]))$/i); + if (quarterMatch) { + const q = quarterMatch[1] || quarterMatch[4]; + const year = quarterMatch[2] || quarterMatch[3]; + return +year * 10 + +q; + } + + const month = parseMonth(text); + if (month) return month; + + const season = parseSeason(text); + if (season) return season; + + const parsedDate = Date.parse(text); + if (!Number.isNaN(parsedDate)) return parsedDate; + + return null; + }; + + const temporalName = /time|date|month|year|season|semester|timestamp|hour|day|week|quarter/i.test(dimensionField); + const temporalValues = dimensionValues + .map(temporalKey) + .filter(v => typeof v === "number" && Number.isFinite(v)); + const isTemporalDimension = temporalName || temporalValues.length === dimensionValues.length; + + const sortedData = [...rawData].sort((a, b) => { + if (isTemporalDimension) { + const ak = temporalKey(a[dimensionField]); + const bk = temporalKey(b[dimensionField]); + if (ak !== null && bk !== null && ak !== bk) return ak - bk; + return a.__originalIndex - b.__originalIndex; + } + const valueDelta = +b[valueField] - +a[valueField]; + if (valueDelta !== 0) return valueDelta; + return a.__originalIndex - b.__originalIndex; + }); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + const prefix = currentLine === "" ? "" : `${currentLine} `; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = prefix + chars + char; + const testLineWithHyphen = prefix + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: prefix + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 4. 尺寸和布局计算 ---------- + + const width = Math.max(variables.width || 800, 1100); + const baseHeight = Math.max(variables.height || 600, 600); + const adjustedHeight = Math.max(560, Math.min(baseHeight, 132 + sortedData.length * 36 + 72)); + const primaryColor = colorResolver.other("primary", { fallback: "#2F7FEA" }).value; + const secondaryColor = colorResolver.other("secondary", { fallback: "#BFD9FF" }).value; + const textColor = colorResolver.text({ fallback: "#10234B" }).value; + const darkText = "#0D2148"; + const mutedText = "#5D6E8D"; + const rightSlotEnabled = width >= 560 && sortedData.length <= 16; + const outerPad = Math.max(10, width * 0.018); + const chartTop = 10; + const chartBottom = 70; + const rowsAreaHeight = adjustedHeight - chartTop - chartBottom; + const rowStep = rowsAreaHeight / sortedData.length; + const rowCardHeight = Math.min(42, Math.max(25, rowStep * 0.86)); + const barHeight = Math.min(23, Math.max(12, rowCardHeight * 0.44)); + const iconBox = Math.min(30, Math.max(18, rowCardHeight * 0.78)); + const iconSize = calcIconSize(iconBox, { maxSize: iconBox * 0.72, minRatio: 0.72, minPx: 12 }); + const labelMaxWidth = rightSlotEnabled ? Math.min(width * 0.12, 118) : width * 0.24; + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: labelMaxWidth, + maxHeight: rowCardHeight * 0.92, + lineSpacing: 1.12, + targetFontSize: Math.min(15.5, rowCardHeight * 0.38) + }); + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + const labelColumnWidth = Math.max(labelMaxWidth, dimLabelLayout.maxLabelWidth + 8); + const rightSlotWidth = rightSlotEnabled ? Math.max(230, Math.min(width * 0.28, 330)) : 0; + const rankX = outerPad + 18; + const iconX = rankX + 34; + const labelX = iconX + iconBox + 16; + const plotX = rightSlotEnabled + ? Math.max(labelX + Math.min(labelColumnWidth, width * 0.11) + 18, width * 0.235) + : labelX + labelColumnWidth + 12; + const rightSlotX = rightSlotEnabled ? width - outerPad - rightSlotWidth : width - outerPad; + const plotRight = rightSlotEnabled ? rightSlotX - 18 : width - outerPad; + const plotWidth = Math.max(120, plotRight - plotX); + const axisY = chartTop + rowsAreaHeight + 18; + const rightSlotY = chartTop + 4; + const rightSlotH = Math.max(230, rowsAreaHeight - 4); + const primaryVisualY = rightSlotY + Math.max(42, rightSlotH * 0.10); + const primaryVisualH = Math.max(100, Math.min(rightSlotH * 0.48, rightSlotH - 178)); + const primaryVisualX = rightSlotX + Math.max(18, rightSlotWidth * 0.12); + const primaryVisualW = Math.max(52, rightSlotWidth - Math.max(36, rightSlotWidth * 0.24)); + const maxValue = d3.max(sortedData, d => +d[valueField]) || 1; + const axisMax = d3.scaleLinear() + .domain([0, maxValue]) + .nice(5) + .domain()[1]; + const xScale = d3.scaleLinear() + .domain([0, axisMax]) + .range([0, plotWidth]); + + const formatValue = (value) => { + const formatted = chartUtils.format.autoText(+value); + return valueUnit ? `${formatted}${valueUnit}` : formatted; + }; + + const formatAxisValue = (value) => { + if (Math.abs(value) >= 1000) return `${chartUtils.format.autoText(value)}`; + return chartUtils.format.autoText(value); + }; + + const humanizeFieldLabel = (fieldName) => { + const raw = String(fieldName || "").trim(); + if (!raw) return ""; + const spaced = raw + .replace(/[_-]+/g, " ") + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + return spaced.replace(/\b\w/g, c => c.toUpperCase()); + }; + + const valueDisplayLabel = humanizeFieldLabel(valueField); + + const roundedRightBarPath = (x, y, w, h, r) => { + const rr = Math.min(r, h / 2, Math.max(0, w)); + return [ + `M ${x},${y}`, + `L ${x + w - rr},${y}`, + `Q ${x + w},${y} ${x + w},${y + rr}`, + `L ${x + w},${y + h - rr}`, + `Q ${x + w},${y + h} ${x + w - rr},${y + h}`, + `L ${x},${y + h}`, + "Z" + ].join(" "); + }; + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", adjustedHeight) + .attr("viewBox", `0 0 ${width} ${adjustedHeight}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const gradient = defs.append("linearGradient") + .attr("id", "hbar10-bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.18 })); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.12 })); + + const shadow = defs.append("filter") + .attr("id", "hbar10-soft-shadow") + .attr("x", "-20%") + .attr("y", "-40%") + .attr("width", "150%") + .attr("height", "190%"); + shadow.append("feDropShadow") + .attr("dx", 1.2) + .attr("dy", 2) + .attr("stdDeviation", 2.2) + .attr("flood-color", "#0A3D88") + .attr("flood-opacity", 0.18); + + const primaryClip = defs.append("clipPath") + .attr("id", "hbar10-primary-visual-clip"); + primaryClip.append("rect") + .attr("x", primaryVisualX) + .attr("y", primaryVisualY) + .attr("width", primaryVisualW) + .attr("height", primaryVisualH) + .attr("rx", 16) + .attr("ry", 16); + + const chart = svg.append("g") + .attr("class", "horizontal-bar-chart-10") + .attr("data-temporal-order", isTemporalDimension ? "chronological" : "value-desc") + .attr("data-reference-endpoint-shape", "square-left-rounded-right") + .attr("data-no-copied-reference-art", "true"); + + sortedData.forEach((dataPoint, index) => { + const dimension = dataPoint[dimensionField]; + const centerY = chartTop + index * rowStep + rowStep / 2; + const rowY = centerY - rowCardHeight / 2; + const barY = centerY - barHeight / 2; + const barWidth = Math.max(2, xScale(+dataPoint[valueField])); + const barRadius = Math.min(10, barHeight / 2); + const formattedValue = formatValue(+dataPoint[valueField]); + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: `${Math.min(17, Math.max(11, barHeight * 0.72))}px`, + fontWeight: 700 + }).width; + const labelInside = barWidth > valueTextWidth + 22; + const valueX = labelInside ? plotX + barWidth - 8 : plotX + barWidth + 8; + + const rowGroup = chart.append("g") + .attr("class", "hbar10-row") + .attr("data-row-index", index) + .attr("data-category", dimension) + .attr("data-value", +dataPoint[valueField]); + + rowGroup.append("line") + .attr("x1", outerPad) + .attr("x2", plotRight + 10) + .attr("y1", rowY + rowCardHeight) + .attr("y2", rowY + rowCardHeight) + .attr("stroke", "#CFE3F5") + .attr("stroke-width", 1) + .attr("stroke-opacity", 0.72); + + rowGroup.append("circle") + .attr("cx", rankX) + .attr("cy", centerY) + .attr("r", Math.min(11, rowCardHeight * 0.31)) + .attr("fill", primaryColor) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1.4); + + rowGroup.append("text") + .attr("x", rankX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(11, rowCardHeight * 0.28)}px`) + .style("font-weight", 700) + .style("fill", "#FFFFFF") + .text(index + 1); + + rowGroup.append("rect") + .attr("x", iconX) + .attr("y", centerY - iconBox / 2) + .attr("width", iconBox) + .attr("height", iconBox) + .attr("rx", 8) + .attr("fill", "#FFFFFF") + .attr("stroke", "#DCEAF7") + .attr("filter", "url(#hbar10-soft-shadow)") + .attr("data-asset-slot", "row-icon") + .attr("data-anchor", "row-centerline") + .attr("data-bbox", `${iconX},${centerY - iconBox / 2},${iconBox},${iconBox}`) + .attr("data-collision", "avoid-row-label-and-rank") + .attr("data-no-copied-reference-art", "true") + .attr("data-no-embedded-raster", "input-provided-only"); + + if (images.field && images.field[dimension]) { + rowGroup.append("image") + .attr("x", iconX + (iconBox - iconSize.width) / 2) + .attr("y", centerY - iconSize.height / 2) + .attr("width", iconSize.width) + .attr("height", iconSize.height) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } else { + rowGroup.append("circle") + .attr("cx", iconX + iconBox / 2) + .attr("cy", centerY) + .attr("r", iconBox * 0.18) + .attr("fill", secondaryColor) + .attr("opacity", 0.7); + } + + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = rowGroup.append("text") + .attr("x", labelX) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", 700) + .style("fill", darkText); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", 0); + labelConfig.lines.forEach((line, lineIndex) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("y", startY + lineIndex * lineHeight) + .attr("dy", "0.35em") + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + rowGroup.append("path") + .attr("class", "hbar10-bar") + .attr("data-endpoint-shape", "square-left-rounded-right") + .attr("data-left-baseline-edge", "square-flat") + .attr("data-right-value-edge", "rounded") + .attr("data-stacked-joins", "not-applicable") + .attr("d", roundedRightBarPath(plotX, barY, barWidth, barHeight, barRadius)) + .attr("fill", "url(#hbar10-bar-gradient)") + .attr("filter", "url(#hbar10-soft-shadow)"); + + rowGroup.append("text") + .attr("x", Math.min(valueX, plotRight - 4)) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", labelInside ? "end" : "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(17, Math.max(11, barHeight * 0.72))}px`) + .style("font-weight", 700) + .style("fill", labelInside ? "#FFFFFF" : colorResolver.variant(primaryColor, { mode: "darker", amount: 0.35 })) + .text(formattedValue); + }); + + const axis = chart.append("g") + .attr("class", "hbar10-axis") + .attr("transform", `translate(${plotX}, ${axisY})`); + + axis.append("line") + .attr("x1", 0) + .attr("x2", plotWidth) + .attr("y1", 0) + .attr("y2", 0) + .attr("stroke", "#8AA5C8") + .attr("stroke-width", 1.2); + + xScale.ticks(5).forEach(tick => { + const x = xScale(tick); + axis.append("line") + .attr("x1", x) + .attr("x2", x) + .attr("y1", -4) + .attr("y2", 4) + .attr("stroke", "#8AA5C8") + .attr("stroke-width", 1); + axis.append("text") + .attr("x", x) + .attr("y", 20) + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", "10px") + .style("font-weight", 500) + .style("fill", mutedText) + .text(formatAxisValue(tick)); + }); + + axis.append("text") + .attr("x", plotWidth / 2) + .attr("y", 42) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "11px") + .style("font-weight", 600) + .style("fill", mutedText) + .text(valueUnit === "$" ? `${valueDisplayLabel} (K$)` : `${valueDisplayLabel}${valueUnit ? ` (${valueUnit})` : ""}`); + + if (rightSlotEnabled) { + const highlightDatum = sortedData.reduce((best, datum) => { + if (!best) return datum; + return +datum[valueField] > +best[valueField] ? datum : best; + }, null) || sortedData[0]; + const slotY = rightSlotY; + const slotH = rightSlotH; + const visualY = primaryVisualY; + const visualH = primaryVisualH; + const visualX = primaryVisualX; + const visualW = primaryVisualW; + const primaryImage = images.other && images.other.primary; + + const slotGroup = chart.append("g") + .attr("class", "hbar10-primary-visual-slot") + .attr("data-asset-slot", "primary-visual") + .attr("data-anchor", "chart-body-right-column") + .attr("data-bbox", `${rightSlotX},${slotY},${rightSlotWidth},${slotH}`) + .attr("data-mask", "hbar10-primary-visual-clip") + .attr("data-collision", "avoid-title-subtitle-bars-labels-values-axis") + .attr("data-no-embedded-raster", "input-provided-only") + .attr("data-no-copied-reference-art", "true"); + + slotGroup.append("rect") + .attr("x", rightSlotX) + .attr("y", slotY) + .attr("width", rightSlotWidth) + .attr("height", slotH) + .attr("rx", 18) + .attr("fill", "rgba(255,255,255,0.78)") + .attr("stroke", "#D8B05B") + .attr("stroke-opacity", 0.7); + + const badge = slotGroup.append("g") + .attr("data-asset-slot", "highlight-badge") + .attr("data-anchor", "right-card-top-center") + .attr("data-bbox", `${rightSlotX + rightSlotWidth / 2 - 14},${slotY - 2},28,28`) + .attr("data-collision", "inside-primary-visual-slot") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + badge.append("circle") + .attr("cx", rightSlotX + rightSlotWidth / 2) + .attr("cy", slotY + 14) + .attr("r", 14) + .attr("fill", "#FFFFFF") + .attr("stroke", primaryColor) + .attr("stroke-width", 2); + badge.append("text") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("y", slotY + 14) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", "12px") + .style("font-weight", 800) + .style("fill", primaryColor) + .text("1"); + + slotGroup.append("rect") + .attr("x", visualX) + .attr("y", visualY) + .attr("width", visualW) + .attr("height", visualH) + .attr("rx", 16) + .attr("fill", "#EAF4FC") + .attr("stroke", "#D3E7F5"); + + if (primaryImage) { + slotGroup.append("image") + .attr("x", visualX) + .attr("y", visualY) + .attr("width", visualW) + .attr("height", visualH) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("clip-path", "url(#hbar10-primary-visual-clip)") + .attr("xlink:href", primaryImage); + } else { + slotGroup.append("text") + .attr("x", visualX + visualW / 2) + .attr("y", visualY + visualH / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", "10px") + .style("font-weight", 700) + .style("fill", mutedText) + .text("IMAGE SLOT"); + } + + const topLabel = String(highlightDatum[dimensionField] || ""); + const topLines = topLabel.split(/\s+/).reduce((lines, word) => { + const last = lines[lines.length - 1] || ""; + const next = last ? `${last} ${word}` : word; + if (next.length > 12 && last) lines.push(word); + else lines[lines.length - 1] = next; + return lines; + }, [""]).slice(0, 3); + + const titleY = visualY + visualH + 30; + const topText = slotGroup.append("text") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("y", titleY) + .attr("text-anchor", "middle") + .style("font-family", typography.title.font_family) + .style("font-size", "17px") + .style("font-weight", 900) + .style("fill", darkText); + + topLines.forEach((line, i) => { + topText.append("tspan") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("dy", i === 0 ? 0 : 19) + .text(line.toUpperCase()); + }); + + const emphasisY = titleY + Math.max(46, topLines.length * 19 + 18); + const emphasisText = slotGroup.append("text") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("y", emphasisY) + .attr("text-anchor", "middle") + .attr("data-card-content", "data-bound-highlight-summary") + .attr("data-no-copied-reference-art", "true") + .style("font-family", typography.title.font_family) + .style("font-size", "15px") + .style("font-weight", 900) + .style("fill", "#C58A23"); + + emphasisText.append("tspan") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("dy", 0) + .text("HIGHEST"); + emphasisText.append("tspan") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("dy", 18) + .text(valueDisplayLabel.toUpperCase()); + + const dividerY = emphasisY + 42; + slotGroup.append("line") + .attr("x1", rightSlotX + 26) + .attr("x2", rightSlotX + rightSlotWidth / 2 - 14) + .attr("y1", dividerY) + .attr("y2", dividerY) + .attr("stroke", "#D8B05B") + .attr("stroke-width", 1.2); + + slotGroup.append("rect") + .attr("x", rightSlotX + rightSlotWidth / 2 - 4) + .attr("y", dividerY - 4) + .attr("width", 8) + .attr("height", 8) + .attr("transform", `rotate(45 ${rightSlotX + rightSlotWidth / 2} ${dividerY})`) + .attr("fill", "#D8B05B") + .attr("data-asset-slot", "neutral-divider-ornament") + .attr("data-anchor", "right-card-divider-center") + .attr("data-bbox", `${rightSlotX + rightSlotWidth / 2 - 4},${dividerY - 4},8,8`) + .attr("data-collision", "inside-right-card-between-emphasis-and-value") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + slotGroup.append("line") + .attr("x1", rightSlotX + rightSlotWidth / 2 + 14) + .attr("x2", rightSlotX + rightSlotWidth - 26) + .attr("y1", dividerY) + .attr("y2", dividerY) + .attr("stroke", "#D8B05B") + .attr("stroke-width", 1.2); + + slotGroup.append("text") + .attr("x", rightSlotX + rightSlotWidth / 2) + .attr("y", dividerY + 33) + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", "20px") + .style("font-weight", 900) + .style("fill", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.2 })) + .text(formatValue(+highlightDatum[valueField])); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_11.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_11.js new file mode 100644 index 0000000000000000000000000000000000000000..7bb28ff36cc97021dfe08eec39781fe7ab2199a8 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_11.js @@ -0,0 +1,574 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_11", + "is_composite": true, + "required_fields": ["x", "y", "y2", "group"], + "required_fields_type": [["categorical", "temporal"], ["numerical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 16], [0, 10000], [0, 10000], [2, 6]], + "required_fields_icons": [], + "hierarchy": ["group"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +// Horizontal bar chart with a secondary value column and group text encoding. +function makeChart(containerSelector, data) { + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const sourceColors = jsonData.colors || { text_color: "#333333", other: { primary: "#1d6b64" }, field: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + variables.has_gradient = variables.has_gradient || false; + + d3.select(containerSelector).html(""); + + const width = Math.max(720, Number(variables.width) || 800); + const baseHeight = Number(variables.height) || 600; + const textColor = sourceColors.text_color || "#333333"; + const primaryColor = sourceColors.other && sourceColors.other.primary ? sourceColors.other.primary : "#1d6b64"; + const labelFont = typography.label || {}; + const valueFont = typography.annotation || {}; + const labelFontSize = parseFloat(labelFont.font_size) || 12; + const valueFontSize = parseFloat(valueFont.font_size) || 12; + + const dimensionField = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw?.name || chartUtils.schema.column(dataColumns, 0).raw?.name || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw?.name || chartUtils.schema.column(dataColumns, 1).raw?.name || "value"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2", { fallbackIndex: 2 }).raw?.name || chartUtils.schema.column(dataColumns, 2).raw?.name || "total"; + const groupField = chartUtils.schema.channel(jsonData, "group", { fallbackIndex: 2 }).raw?.name || chartUtils.schema.column(dataColumns, 3).raw?.name || "group"; + const dimensionColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const valueColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const valueColumn2 = chartUtils.schema.channel(jsonData, "y2", { fallbackIndex: 2 }).raw || {}; + + const valueUnit = valueColumn.unit && valueColumn.unit !== "none" ? valueColumn.unit : ""; + const valueUnit2 = valueColumn2.unit && valueColumn2.unit !== "none" ? valueColumn2.unit : ""; + function humanizeFieldName(name) { + return String(name ?? "") + .replace(/[_-]+/g, " ") + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim() + .replace(/\b\w/g, letter => letter.toUpperCase()); + } + + function displayColumnName(column, fallbackName) { + const raw = column.display_name || column.label || fallbackName; + const readable = humanizeFieldName(raw); + const unit = column.unit && column.unit !== "none" ? column.unit : ""; + return unit && !readable.includes(unit) ? `${readable} (${unit})` : readable; + } + + const dimensionDisplayName = displayColumnName(dimensionColumn, dimensionField); + const valueFieldName = displayColumnName(valueColumn, valueField); + const valueField2Name = displayColumnName(valueColumn2, valueField2); + + function parseTemporalSortValue(value) { + const text = String(value ?? "").trim(); + let match = text.match(/^(-?\d{1,6})$/); + if (match) return Number(match[1]); + match = text.match(/^(-?\d{1,6})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) { + return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + } + return NaN; + } + + function formatLocalValue(value) { + const numericValue = Number(value); + if (!Number.isFinite(numericValue)) return String(value ?? ""); + const absValue = Math.abs(numericValue); + if (absValue >= 1000000000) return `${d3.format(".3~g")(numericValue / 1000000000)}B`; + if (absValue >= 1000000) return `${d3.format(".3~g")(numericValue / 1000000)}M`; + if (absValue >= 1000) return `${d3.format(".3~g")(numericValue / 1000)}K`; + return d3.format(",.4~g")(numericValue); + } + + function withUnit(value, unit) { + const formatted = formatLocalValue(value); + return unit ? `${formatted} ${unit}` : formatted; + } + + const temporalSortValues = chartData.map(d => parseTemporalSortValue(d[dimensionField])); + const hasTemporalLikeX = ( + dimensionColumn.data_type === "temporal" || + temporalSortValues.every(Number.isFinite) + ); + + const sortedData = [...chartData].sort((a, b) => { + const aTemporal = parseTemporalSortValue(a[dimensionField]); + const bTemporal = parseTemporalSortValue(b[dimensionField]); + if (hasTemporalLikeX && Number.isFinite(aTemporal) && Number.isFinite(bTemporal)) { + return aTemporal - bTemporal; + } + return Number(b[valueField]) - Number(a[valueField]); + }); + + const groups = Array.from(new Set(sortedData.map(d => String(d[groupField] ?? "")))); + const fallbackPalette = [ + primaryColor, + chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 0.8 }), + chartUtils.color.variant(primaryColor, { mode: "darker", amount: 0.8 }), + "#5b8def", + "#d47b51", + "#6c9f6b" + ]; + const groupColor = d3.scaleOrdinal() + .domain(groups) + .range(groups.map((group, index) => { + return (sourceColors.field && sourceColors.field[group]) || fallbackPalette[index % fallbackPalette.length]; + })); + + const rowCount = Math.max(sortedData.length, 1); + const compact = width < 520 || rowCount > 10; + const rowHeight = compact ? 48 : 64; + const rowGap = compact ? 5 : 8; + const outerPad = Math.max(12, Math.min(22, width * 0.03)); + const headerHeight = compact ? 48 : 58; + const chartTop = outerPad + 14; + const bodyTop = chartTop + headerHeight + 10; + const bodyHeight = rowCount * rowHeight + Math.max(0, rowCount - 1) * rowGap; + const height = Math.max(baseHeight, bodyTop + bodyHeight + outerPad + 16); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const shadowFilter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "150%"); + shadowFilter.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 3) + .attr("flood-color", "#0b3b3f") + .attr("flood-opacity", 0.16); + + const gradient = defs.append("linearGradient") + .attr("id", "horizontal-bar-gradient-11") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 0.62 })); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", chartUtils.color.variant(primaryColor, { mode: "darker", amount: 0.16 })); + + function measureLabelText(text, fontFamily, fontSize, fontWeight) { + const node = svg.append("text") + .style("visibility", "hidden") + .style("font-family", fontFamily) + .style("font-size", fontSize) + .style("font-weight", fontWeight) + .text(String(text ?? "")); + const bbox = chartUtils.text.nodeSize(node.node()); + node.remove(); + return bbox.width; + } + + function splitLabelLines(text, maxWidth, fontFamily, fontSize, fontWeight, maxLines = 2) { + const rawText = String(text ?? "").trim(); + if (!rawText) return [""]; + if (measureLabelText(rawText, fontFamily, fontSize, fontWeight) <= maxWidth) { + return [rawText]; + } + const words = rawText + .replace(/[()[\]{}]/g, " ") + .replace(/[,:;/\\|_-]+/g, " ") + .split(/\s+/) + .filter(Boolean); + if (words.length <= 1) return [rawText]; + + const lines = []; + let current = ""; + for (const word of words) { + const candidate = current ? `${current} ${word}` : word; + if (measureLabelText(candidate, fontFamily, fontSize, fontWeight) <= maxWidth || current === "") { + current = candidate; + continue; + } + lines.push(current); + current = word; + if (lines.length === maxLines - 1) break; + } + if (current && lines.length < maxLines) lines.push(current); + return lines.slice(0, maxLines); + } + + const panelFill = "#f7fbf8"; + const navy = "#092244"; + const teal = primaryColor; + const tealDark = chartUtils.color.variant(primaryColor, { mode: "darker", amount: 0.65 }); + const tealPale = chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 1.55 }); + const bodyX = outerPad; + const bodyWidth = width - outerPad * 2; + const labelColW = Math.max(132, Math.min(width * 0.34, bodyWidth * 0.28)); + const secondaryColW = Math.max(86, Math.min(width * 0.23, bodyWidth * 0.2)); + const iconSlot = compact ? 28 : 36; + const leftTextX = bodyX + iconSlot + 18; + const rightColX = bodyX + bodyWidth - secondaryColW; + const barX = bodyX + labelColW + 16; + const barW = Math.max(90, rightColX - barX - 16); + const xMax = d3.max(sortedData, d => Number(d[valueField])) || 1; + const xScale = d3.scaleLinear() + .domain([0, xMax * 1.05]) + .range([0, barW]); + + svg.append("rect") + .attr("class", "chart-background-panel") + .attr("x", outerPad / 2) + .attr("y", outerPad / 2) + .attr("width", width - outerPad) + .attr("height", height - outerPad) + .attr("rx", Math.max(14, width * 0.025)) + .attr("fill", panelFill) + .attr("stroke", chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 1.65 })) + .attr("stroke-width", 1); + + const header = svg.append("g") + .attr("class", "chart-header-band"); + header.append("rect") + .attr("x", bodyX) + .attr("y", chartTop) + .attr("width", bodyWidth) + .attr("height", headerHeight) + .attr("rx", 10) + .attr("fill", tealDark) + .attr("filter", "url(#shadow)"); + header.append("rect") + .attr("x", bodyX + labelColW) + .attr("y", chartTop) + .attr("width", barW + 32) + .attr("height", headerHeight) + .attr("fill", teal) + .attr("opacity", 0.85); + header.append("line") + .attr("x1", bodyX + labelColW) + .attr("x2", bodyX + labelColW) + .attr("y1", chartTop) + .attr("y2", chartTop + headerHeight) + .attr("stroke", "#ffffff") + .attr("stroke-opacity", 0.75); + header.append("line") + .attr("x1", rightColX) + .attr("x2", rightColX) + .attr("y1", chartTop) + .attr("y2", chartTop + headerHeight) + .attr("stroke", "#ffffff") + .attr("stroke-opacity", 0.75); + + function addHeaderText(text, x, anchor, maxWidth) { + const words = splitLabelLines(text, maxWidth, "Arial", `${compact ? 10 : 12}px`, 700, 2); + const group = header.append("text") + .attr("x", x) + .attr("y", chartTop + headerHeight / 2 - (words.length - 1) * 7) + .attr("text-anchor", anchor) + .style("dominant-baseline", "middle") + .style("font-family", "Arial") + .style("font-size", `${compact ? 10 : 12}px`) + .style("font-weight", 700) + .style("letter-spacing", "0") + .style("fill", "#ffffff"); + words.forEach((line, i) => { + group.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : 14) + .text(line.toUpperCase()); + }); + } + addHeaderText(dimensionDisplayName, bodyX + labelColW / 2, "middle", labelColW - 18); + addHeaderText(valueFieldName, barX + barW / 2, "middle", barW - 18); + addHeaderText(valueField2Name, rightColX + secondaryColW / 2, "middle", secondaryColW - 12); + + const rowLabelFontSize = Math.max(11, Math.min(15, labelFontSize * (compact ? 0.78 : 0.9))); + const groupFontSize = Math.max(8, Math.min(11, rowLabelFontSize * 0.78)); + const primaryValueFontSize = Math.max(10, Math.min(14, valueFontSize * 0.98)); + const secondaryFontSize = Math.max(15, Math.min(23, valueFontSize * (compact ? 1.15 : 1.45))); + const barHeight = compact ? 20 : 26; + const rightTopicSlotSize = Math.max(20, Math.min(compact ? 27 : 34, secondaryColW * 0.23, rowHeight - 18)); + const rightTopicSlotX = rightColX + secondaryColW - rightTopicSlotSize - 13; + const secondaryTextX = rightColX + secondaryColW * 0.43; + const showPerRowTicks = rowCount <= 7 && !compact; + + sortedData.forEach((d, index) => { + const y = bodyTop + index * (rowHeight + rowGap); + const rowCenterY = y + rowHeight / 2; + const group = String(d[groupField] ?? ""); + const barColor = groupColor(group); + const barWidth = Math.max(1, xScale(Number(d[valueField]) || 0)); + const valueText = withUnit(d[valueField], valueUnit); + const secondaryText = withUnit(d[valueField2], valueUnit2); + + svg.append("rect") + .attr("class", "row-card") + .attr("x", bodyX) + .attr("y", y) + .attr("width", bodyWidth) + .attr("height", rowHeight) + .attr("rx", compact ? 8 : 12) + .attr("fill", "#ffffff") + .attr("stroke", chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 1.45 })) + .attr("stroke-width", 0.6) + .attr("filter", "url(#shadow)"); + + const icon = svg.append("g") + .attr("class", "asset-slot row-icon-slot") + .attr("data-asset-slot", "row-icon") + .attr("data-asset-anchor", "row-center") + .attr("data-asset-row-index", index) + .attr("data-asset-bbox", `${bodyX + 12},${rowCenterY - iconSlot / 2},${iconSlot},${iconSlot}`) + .attr("data-asset-collision", "avoid-row-label-and-card-edge") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + icon.append("circle") + .attr("cx", bodyX + 12 + iconSlot / 2) + .attr("cy", rowCenterY) + .attr("r", iconSlot / 2) + .attr("fill", chartUtils.color.variant(barColor, { mode: "brighter", amount: 1.2 })) + .attr("stroke", barColor) + .attr("stroke-width", 1.2) + .attr("opacity", 0.95); + icon.append("circle") + .attr("cx", bodyX + 12 + iconSlot / 2) + .attr("cy", rowCenterY) + .attr("r", Math.max(3, iconSlot * 0.12)) + .attr("fill", barColor) + .attr("opacity", 0.65); + + const labelLines = splitLabelLines( + d[dimensionField], + Math.max(48, labelColW - iconSlot - 32), + "Arial", + `${rowLabelFontSize}px`, + 700, + 2 + ); + const label = svg.append("text") + .attr("class", "label") + .attr("x", leftTextX) + .attr("y", rowCenterY - (labelLines.length > 1 ? 8 : 3)) + .attr("text-anchor", "start") + .style("font-family", labelFont.font_family || "Arial") + .style("font-size", `${rowLabelFontSize}px`) + .style("font-weight", 700) + .style("fill", navy); + labelLines.forEach((line, lineIndex) => { + label.append("tspan") + .attr("x", leftTextX) + .attr("dy", lineIndex === 0 ? 0 : rowLabelFontSize + 1) + .text(line); + }); + + svg.append("text") + .attr("class", "group-label") + .attr("x", leftTextX) + .attr("y", rowCenterY + rowLabelFontSize + 6) + .attr("text-anchor", "start") + .style("font-family", labelFont.font_family || "Arial") + .style("font-size", `${groupFontSize}px`) + .style("fill", "#566373") + .text(group); + + svg.append("line") + .attr("class", "axis-baseline") + .attr("x1", barX) + .attr("x2", barX + barW) + .attr("y1", rowCenterY + barHeight / 2 + 8) + .attr("y2", rowCenterY + barHeight / 2 + 8) + .attr("stroke", "#6b7a8e") + .attr("stroke-width", 0.6) + .attr("opacity", showPerRowTicks ? 0.22 : 0.1); + if (showPerRowTicks) { + [0, 0.5, 1].forEach(tick => { + const tickX = barX + barW * tick; + svg.append("text") + .attr("class", "axis-tick") + .attr("x", tickX) + .attr("y", rowCenterY + barHeight / 2 + 22) + .attr("text-anchor", "middle") + .style("font-family", "Arial") + .style("font-size", "8px") + .style("fill", "#566373") + .style("opacity", 0.74) + .text(tick === 0 ? "0" : tick === 0.5 ? "50%" : "100%"); + }); + } + + const barGradientId = `horizontal-bar-gradient-11-${index}`; + const localGradient = defs.append("linearGradient") + .attr("id", barGradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + localGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", chartUtils.color.variant(barColor, { mode: "brighter", amount: 0.55 })); + localGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", chartUtils.color.variant(barColor, { mode: "darker", amount: 0.1 })); + + const radius = Math.min(6, barHeight * 0.22); + svg.append("rect") + .attr("class", "bar mark") + .attr("data-row-index", index) + .attr("data-category", String(d[dimensionField] ?? "")) + .attr("data-value", Number(d[valueField]) || 0) + .attr("x", barX) + .attr("y", rowCenterY - barHeight / 2) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", radius) + .attr("ry", radius) + .attr("fill", `url(#${barGradientId})`) + .attr("stroke", chartUtils.color.variant(barColor, { mode: "darker", amount: 0.25 })) + .attr("stroke-width", 0.8) + .style("opacity", 0.96); + + const valueTextWidth = measureLabelText(valueText, "Arial", `${primaryValueFontSize}px`, 700); + const fitsInside = barWidth > valueTextWidth + 12; + svg.append("text") + .attr("class", "value primary-value") + .attr("x", fitsInside ? barX + barWidth - 7 : barX + barWidth + 6) + .attr("y", rowCenterY + 1) + .attr("text-anchor", fitsInside ? "end" : "start") + .style("dominant-baseline", "middle") + .style("font-family", valueFont.font_family || "Arial") + .style("font-size", `${primaryValueFontSize}px`) + .style("font-weight", 700) + .style("fill", fitsInside ? "#ffffff" : navy) + .text(valueText); + + svg.append("line") + .attr("class", "secondary-divider") + .attr("x1", rightColX) + .attr("x2", rightColX) + .attr("y1", y + 8) + .attr("y2", y + rowHeight - 8) + .attr("stroke", chartUtils.color.variant(primaryColor, { mode: "brighter", amount: 1.25 })) + .attr("stroke-width", 1); + + const topicSlot = svg.append("g") + .attr("class", "asset-slot right-column-topic-art-slot") + .attr("data-asset-slot", "right-column-topic-art") + .attr("data-asset-anchor", "right-secondary-cell-far-right") + .attr("data-asset-row-index", index) + .attr("data-asset-bbox", `${rightTopicSlotX},${rowCenterY - rightTopicSlotSize / 2},${rightTopicSlotSize},${rightTopicSlotSize}`) + .attr("data-asset-collision", "avoid-secondary-value-divider-row-card-and-adjacent-rows") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + topicSlot.append("rect") + .attr("x", rightTopicSlotX) + .attr("y", rowCenterY - rightTopicSlotSize / 2) + .attr("width", rightTopicSlotSize) + .attr("height", rightTopicSlotSize) + .attr("rx", rightTopicSlotSize * 0.32) + .attr("fill", tealPale) + .attr("opacity", 0.28); + topicSlot.append("line") + .attr("x1", rightTopicSlotX + rightTopicSlotSize * 0.24) + .attr("x2", rightTopicSlotX + rightTopicSlotSize * 0.76) + .attr("y1", rowCenterY) + .attr("y2", rowCenterY) + .attr("stroke", tealDark) + .attr("stroke-width", Math.max(1.2, rightTopicSlotSize * 0.08)) + .attr("stroke-linecap", "round") + .attr("opacity", 0.2); + + svg.append("text") + .attr("class", "value secondary-value") + .attr("x", secondaryTextX) + .attr("y", rowCenterY + 1) + .attr("text-anchor", "middle") + .style("dominant-baseline", "middle") + .style("font-family", valueFont.font_family || "Arial") + .style("font-size", `${secondaryFontSize}px`) + .style("font-weight", 700) + .style("fill", navy) + .text(secondaryText); + }); + + if (!showPerRowTicks) { + const bottomAxisY = bodyTop + bodyHeight + 8; + svg.append("line") + .attr("class", "axis-baseline axis-baseline-shared") + .attr("x1", barX) + .attr("x2", barX + barW) + .attr("y1", bottomAxisY) + .attr("y2", bottomAxisY) + .attr("stroke", "#6b7a8e") + .attr("stroke-width", 0.7) + .attr("opacity", 0.28); + [0, 0.5, 1].forEach(tick => { + const tickX = barX + barW * tick; + svg.append("text") + .attr("class", "axis-tick axis-tick-shared") + .attr("x", tickX) + .attr("y", bottomAxisY + 13) + .attr("text-anchor", "middle") + .style("font-family", "Arial") + .style("font-size", "8px") + .style("fill", "#566373") + .style("opacity", 0.78) + .text(tick === 0 ? "0" : tick === 0.5 ? "50%" : "100%"); + }); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..16953d134d0064e36d8dd2ccfc4ea6274a83a9ec --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_12.js @@ -0,0 +1,719 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_12", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 600, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 60, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值 + bottom: 30, // 底部边距 + left: 220 // 左侧空间用于参考图的图标列和标签列 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 如果x维度数量超过15，每增加一个x，整个图像的高度增加3% + const baseHeight = variables.height || 600; + const adjustedHeight = dimensions.length > 15 + ? baseHeight * (1 + (dimensions.length - 15) * 0.03) + : baseHeight; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算图标尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = formatDisplayLabel(labels[i]); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = formatDisplayLabel(label); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度 ---------- + + // 计算条形高度和图标尺寸 + const barPadding = variables.has_spacing ? 0.3 : 0.2; + const tempYScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, height - margin.top - margin.bottom]) + .padding(barPadding); + + const barHeight = tempYScale.bandwidth(); + const iconSize = calcIconSize(barHeight, { maxSize: 48, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + const flagPadding = 5; + + // 使用智能换行计算维度标签布局 + const formatDisplayLabel = (text) => String(text || "") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + + const labelFontSize = Math.min(parseFloat(typography.label.font_size) || 12, 12.5); + const labelMaxWidth = 120; + const labelMaxHeight = barHeight; + const labelLineSpacing = 1.2; + + const labelLayoutResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: { + font_family: typography.label.font_family, + font_weight: typography.label.font_weight + }, + maxWidth: labelMaxWidth, + maxHeight: labelMaxHeight, + lineSpacing: labelLineSpacing, + targetFontSize: labelFontSize + }); + + const dimLabelConfig = labelLayoutResult.dimLabelConfig; + const maxLabelWidth = labelLayoutResult.maxLabelWidth; + + // 计算最大数值标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + tempSvg.remove(); + + // 根据标签宽度调整左边距 + const totalLabelWidth = flagWidth + flagPadding + maxLabelWidth; + margin.left = Math.max(margin.left, totalLabelWidth + 20); + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + const primaryColor = colorResolver.other("primary", { fallback: "#F28A22" }).value; + const barGradientId = `bar-gradient-${Math.random().toString(36).slice(2)}`; + const rowShadowId = `row-shadow-${Math.random().toString(36).slice(2)}`; + + const barGradient = defs.append("linearGradient") + .attr("id", barGradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + barGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.08 })); + + barGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.42 })); + + const rowShadow = defs.append("filter") + .attr("id", rowShadowId) + .attr("x", "-8%") + .attr("y", "-20%") + .attr("width", "116%") + .attr("height", "140%"); + + rowShadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 2.2) + .attr("flood-color", "#153B4D") + .attr("flood-opacity", 0.10); + + // ---------- 7. 创建比例尺 ---------- + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 8. 添加标题和副标题 ---------- + + // 添加标题（如果有） + if (variables.title && variables.title.text) { + svg.append("text") + .attr("x", margin.left) + .attr("y", margin.top / 2) + .attr("text-anchor", "start") + .style("font-family", typography.title.font_family) + .style("font-size", typography.title.font_size) + .style("font-weight", typography.title.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(variables.title.text); + } + + // 添加副标题（如果有） + if (variables.subtitle && variables.subtitle.text) { + svg.append("text") + .attr("x", margin.left) + .attr("y", margin.top / 2 + 20) + .attr("text-anchor", "start") + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(variables.subtitle.text); + } + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + const rowCardX = -margin.left + 10; + const rowCardWidth = innerWidth + margin.left + margin.right - 20; + const labelColumnX = -22; + const iconX = -margin.left + 28; + const cardGap = Math.max(6, yScale.step() * 0.08); + const valueColor = "#0F6B58"; + const labelColor = "#0B253D"; + + const rightRoundedBarPath = (x, y, w, h, r) => { + const radius = Math.max(0, Math.min(r, h / 2, w)); + if (w <= radius) { + return `M${x},${y}H${x + w}V${y + h}H${x}Z`; + } + return [ + `M${x},${y}`, + `H${x + w - radius}`, + `Q${x + w},${y} ${x + w},${y + radius}`, + `V${y + h - radius}`, + `Q${x + w},${y + h} ${x + w - radius},${y + h}`, + `H${x}`, + "Z" + ].join(""); + }; + + const slotW = Math.min(rowCardWidth * 0.54, Math.max(innerWidth * 0.86, 250)); + const slotH = Math.min(innerHeight * 0.44, Math.max(160, innerHeight * 0.30)); + const slotX = Math.max(labelColumnX + 54, innerWidth - slotW + margin.right * 0.52); + const slotY = Math.max(innerHeight * 0.56, innerHeight - slotH + 4); + const assetSlot = g.append("g") + .attr("class", "reserved-asset-slot lower-right-illustration-slot") + .attr("data-asset-slot", "lower_right_context_illustration") + .attr("data-asset-source", "image2_asset") + .attr("data-bbox", `${slotX},${slotY},${slotW},${slotH}`) + .attr("data-anchor", "plot-lower-right") + .attr("data-collision-rule", "large lower-right body slot behind row-cards-and-bars; downstream asset must avoid labels, baseline, bars, values, and canvas edge") + .attr("data-mask", "plot-lower-right-large-reference-footprint") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-reference-footprint", "selected-reference-large-lower-right-context-illustration") + .attr("opacity", 0.72); + + assetSlot.append("rect") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 24) + .attr("fill", "#CFEDE6") + .attr("opacity", 0.30) + .attr("stroke", "#62BDAF") + .attr("stroke-width", 1.4) + .attr("stroke-dasharray", "9 7"); + + assetSlot.append("path") + .attr("d", `M${slotX + slotW * 0.06},${slotY + slotH * 0.78} C${slotX + slotW * 0.28},${slotY + slotH * 0.50} ${slotX + slotW * 0.54},${slotY + slotH * 0.92} ${slotX + slotW * 0.94},${slotY + slotH * 0.60}`) + .attr("fill", "none") + .attr("stroke", "#57B7A6") + .attr("stroke-width", Math.max(16, Math.min(28, slotH * 0.14))) + .attr("stroke-linecap", "round") + .attr("opacity", 0.20); + + assetSlot.append("circle") + .attr("cx", slotX + slotW * 0.72) + .attr("cy", slotY + slotH * 0.36) + .attr("r", Math.min(slotW, slotH) * 0.26) + .attr("fill", "#57B7A6") + .attr("opacity", 0.16); + + assetSlot.append("line") + .attr("x1", slotX + slotW * 0.18) + .attr("y1", slotY + slotH * 0.28) + .attr("x2", slotX + slotW * 0.70) + .attr("y2", slotY + slotH * 0.66) + .attr("stroke", "#2E8F83") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "7 8") + .attr("opacity", 0.14); + + // Reference row geometry: independent rounded cards span the label, baseline, bar, and value columns. + sortedDimensions.forEach((dimension) => { + g.append("rect") + .attr("x", rowCardX) + .attr("y", yScale(dimension) + cardGap / 2) + .attr("width", rowCardWidth) + .attr("height", yScale.bandwidth() - cardGap) + .attr("rx", 8) + .attr("class", "row-card") + .attr("data-relationship", "grid-row-span-matched") + .attr("fill", "#FFFFFF") + .attr("opacity", 0.92) + .style("filter", `url(#${rowShadowId})`); + }); + + g.append("line") + .attr("class", "bar-baseline-divider") + .attr("data-relationship", "flush-baseline-for-bar-left-edges") + .attr("x1", 0) + .attr("x2", 0) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", "#C6B9AA") + .attr("stroke-width", 1.2); + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + const visualBarHeight = Math.max(10, Math.min(34, barHeight * 0.58)); + const visualBarY = yScale(dimension) + (barHeight - visualBarHeight) / 2; + const barRadius = Math.min(8, visualBarHeight / 2); + + // 绘制条形：左端与基线齐平，右端圆角，匹配所选参考图的端点几何。 + g.append("path") + .attr("d", rightRoundedBarPath(0, visualBarY, barWidth, visualBarHeight, barRadius)) + .attr("class", "bar-mark") + .attr("data-bar-endpoint-geometry", "left-baseline-flat,right-value-rounded") + .attr("fill", `url(#${barGradientId})`) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 添加带图标的维度标签 + const centerY = yScale(dimension) + barHeight / 2; + const labelX = labelColumnX; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("class", "field-icon input-asset-icon") + .attr("data-asset-slot", `field_icon_${String(dimension).replace(/[^a-z0-9]+/gi, "_").toLowerCase()}`) + .attr("data-asset-source", "input-provided") + .attr("data-anchor", "row-card-left-center") + .attr("data-collision-rule", "inside row card before label column") + .attr("data-no-copied-reference-art", "true") + .attr("x", iconX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } else { + g.append("circle") + .attr("class", "field-icon neutral-placeholder") + .attr("data-asset-slot", `field_icon_${String(dimension).replace(/[^a-z0-9]+/gi, "_").toLowerCase()}`) + .attr("data-asset-source", "neutral_placeholder") + .attr("data-anchor", "row-card-left-center") + .attr("data-collision-rule", "inside row card before label column") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("cx", iconX + flagWidth / 2) + .attr("cy", centerY) + .attr("r", Math.min(flagWidth, flagHeight) / 2) + .attr("fill", "#E8F4F1") + .attr("stroke", "#BFD9D3") + .attr("stroke-width", 1); + } + + // 添加维度标签（支持多行换行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", labelX) + .attr("class", "category-label") + .attr("data-relationship", "centerline-aligned-to-row-card-and-icon") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", 700) + .style("fill", labelColor); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + g.append("text") + .attr("x", barWidth + 10) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("class", "value-label") + .attr("data-relationship", "value-label-floats-after-rounded-bar-end") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(22,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", 800) + .style("fill", valueColor) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_13.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_13.js new file mode 100644 index 0000000000000000000000000000000000000000..b39ead94cb00ad08372c00b3c9e54bd72c8c5938 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_13.js @@ -0,0 +1,531 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_13", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 20], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 设置视觉效果默认值 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : true; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + let currentChartHeight = variables.height || 600; // 初始化图表高度，后续可能调整 + + // 设置边距 + const margin = { + top: 100, // 顶部标题空间 + right: 5, // 右侧边距 + bottom: 40, // 底部边距 + left: 0 // 左侧边距（条形图紧贴左边） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // -- 动态调整SVG高度 -- + if (sortedDimensions.length > 15) { + const excessDimensions = sortedDimensions.length - 15; + const percentIncrease = excessDimensions * 0.03; // 每增加一个维度，高度增加3% + currentChartHeight = Math.round(currentChartHeight * (1 + percentIncrease)); + } + // -- 结束动态调整SVG高度 -- + + // 添加数值格式化函数 + + // 5. 布局计算 + const flagMargin = 10; + const textMargin = 5; + + // 设置条形图和圆形图的布局比例 + const leftColumnRatio = 0.85; // 左列占比 + const rightColumnRatio = 0.15; // 右列占比 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = currentChartHeight - margin.top - margin.bottom; // 使用调整后的高度 + + // 计算两列的宽度 + const barChartWidth = innerWidth * leftColumnRatio; + const circleChartWidth = innerWidth * rightColumnRatio; + + // 6. 创建比例尺 + const barPadding = variables.has_spacing ? 0.3 : 0.1; + + // Y轴比例尺（维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（第一个数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barChartWidth]); + + // 圆形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minRadius = yScale.bandwidth() * 0.3; // 最小半径 + const maxRadius = Math.min(yScale.bandwidth() * 1.0, circleChartWidth*0.5) // 最大半径 + + const radiusScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // 新增: 动态计算图标（flag）的尺寸 + const barHeightForIconScaling = yScale.bandwidth(); + const barHeightThresholdForIcon = 35; // px, 用于切换图标缩放比例的阈值 + // 如果条形高度较低，则图标相对条形较大 (80%)；如果条形高度较高，则图标相对条形较小 (60%) + const iconScaleFactor = barHeightForIconScaling < barHeightThresholdForIcon ? 0.8 : 0.6; + // 计算图标尺寸，确保最小为10px，且不超过条形本身的高度 + const calculatedFlagSize = Math.min( + barHeightForIconScaling, + Math.max(10, Math.round(barHeightForIconScaling * iconScaleFactor)) + ); + + const flagWidth = calculatedFlagSize; + const flagHeight = calculatedFlagSize; + + // 7. 创建SVG容器 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", currentChartHeight) // 使用调整后的高度 + .attr("viewBox", `0 0 ${width} ${currentChartHeight}`) // 使用调整后的高度 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // Define clip path for bars + const clipPathId = "bar-clip-path"; + svg.append("defs") + .append("clipPath") + .attr("id", clipPathId) + .append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", barChartWidth) // Clip at the right edge of the bar area + .attr("height", innerHeight); + + // 8. 添加标题 + const tempTextSvg = svg.append("g").attr("visibility", "hidden"); + + // ---------- Helper: Estimate Generic Text Width ---------- + const estimateGenericTextWidth = (text, fontConfig, tempSvg) => { + return chartUtils.text.measure(tempSvg, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- Helper: Get Wrapped Lines ---------- + function getWrappedLines(textContent, availableWidth, fontConfig, tempSvg) { + const words = (textContent || "").trim().split(/\s+/).filter(w => w !== ""); + const lines = []; + // 使用 parseFloat 解析字体大小（例如 "16px" -> 16），然后乘以1.2作为行高估计 + const fontSizeValue = parseFloat(fontConfig.font_size); + const lineHeight = fontSizeValue * 1.2; + + if (words.length === 0) { + return { linesArray: [], numLines: 0, lineHeight: lineHeight }; + } + + let currentLine = words[0]; + for (let i = 1; i < words.length; i++) { + const word = words[i]; + const testLine = currentLine + " " + word; + if (estimateGenericTextWidth(testLine, fontConfig, tempSvg) > availableWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + if (currentLine !== "") { + lines.push(currentLine); + } + + return { linesArray: lines, numLines: lines.length, lineHeight: lineHeight }; + } + + const estimateLabelWidth = (text, fontConfig, barHeight) => { + // Calculate dynamic font size for value labels if applicable + const isValueLabel = fontConfig === typography.annotation; + const fontSize = isValueLabel ? `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px` : fontConfig.font_size; + + return chartUtils.text.measure(tempTextSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 8. 添加标题 (重构部分) ---------- + const titleFontConfig = typography.description; + const titleBottomPadding = 10; // 标题底部与图表顶部之间的间距 + const desiredBaselineOfLastLine = margin.top - titleBottomPadding; + + // 左侧列标题 + const leftTitleAvailableWidth = innerWidth * 0.6; + const leftTitleXPos = margin.left; + const wrappedLeftTitle = getWrappedLines(columnTitle1, leftTitleAvailableWidth, titleFontConfig, tempTextSvg); + + if (wrappedLeftTitle.numLines > 0) { + const initialYLeft = desiredBaselineOfLastLine - (wrappedLeftTitle.numLines - 1) * wrappedLeftTitle.lineHeight; + const leftTitleText = svg.append("text") + .attr("x", leftTitleXPos) + .attr("y", initialYLeft) + .attr("text-anchor", "start") + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedLeftTitle.linesArray.forEach((line, i) => { + leftTitleText.append("tspan") + .attr("x", leftTitleXPos) + .attr("dy", i === 0 ? 0 : wrappedLeftTitle.lineHeight) + .text(line); + }); + } + + // 右侧列标题 + const rightTitleAvailableWidth = innerWidth * 0.4; + const rightTitleXPos = margin.left + innerWidth; // 新的右对齐X坐标 (即：allocated space for left + allocated space for right) + const wrappedRightTitle = getWrappedLines(columnTitle2, rightTitleAvailableWidth, titleFontConfig, tempTextSvg); + + if (wrappedRightTitle.numLines > 0) { + const initialYRight = desiredBaselineOfLastLine - (wrappedRightTitle.numLines - 1) * wrappedRightTitle.lineHeight; + const rightTitleText = svg.append("text") + .attr("x", rightTitleXPos) + .attr("y", initialYRight) + .attr("text-anchor", "end") // 右侧标题修改为end对齐 + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedRightTitle.linesArray.forEach((line, i) => { + rightTitleText.append("tspan") + .attr("x", rightTitleXPos) // tspan也使用相同的X坐标，由text-anchor控制对齐 + .attr("dy", i === 0 ? 0 : wrappedRightTitle.lineHeight) + .text(line); + }); + } + // ---------- 结束添加标题 ---------- + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形图颜色 + const getBarColor = (dimension) => { + + return colorResolver.other("primary", { fallback: "#83C341" }).value; // 亮绿色 + }; + + // 获取圆形图颜色 + const getCircleColor = (dimension) => { + + return colorResolver.other("primary", { fallback: "#83C341" }).value; // 亮绿色 + }; + + // 存储第一个条形的宽度，用于后续条形图标签位置决策 + let firstBarWidth = 0; + if (sortedDimensions.length > 0) { + const firstDataPoint = chartData.find(d => d[dimensionField] === sortedDimensions[0]); + if (firstDataPoint) { + firstBarWidth = xScale(+firstDataPoint[valueField1]); + } + } + + // 为每个维度绘制条形和圆形 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = xScale(+dataPoint[valueField1]); + const barRadius = barHeight / 2; // 条形图右侧圆角半径 + + // --- Calculate Element Widths and Spaces --- + const iconSize = flagWidth; // 图标大小 + const textPadding = 5; // 文本内边距 + + const dimensionLabelText = dimension.toUpperCase(); + const valueLabelText = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + + const currentDimLabelWidth = estimateLabelWidth(dimensionLabelText, typography.label, barHeight); + const currentValueLabelWidth = estimateLabelWidth(valueLabelText, typography.annotation, barHeight); + + const iconMinSpace = iconSize + textPadding; // 仅图标所需空间 + const totalIconDimSpace = iconMinSpace + currentDimLabelWidth + textPadding; // 图标+维度标签所需空间 + const totalInsideSpace = totalIconDimSpace + currentValueLabelWidth + textPadding * 2; // 所有元素所需空间 + + // --- Determine Positioning Strategy based on barWidthValue --- + let iconX, dimLabelX, valueLabelX; + let dimLabelColor, valueLabelColor; + let dimLabelAnchor, valueLabelAnchor; + let lineStartX; // 连接线起点 + + if (barWidthValue < iconMinSpace) { + // 策略1：所有元素放在外部 + iconX = barWidthValue + textPadding; + dimLabelX = iconX + iconSize + textPadding; + valueLabelX = dimLabelX + currentDimLabelWidth + 15; + + dimLabelColor = colorResolver.text({ fallback: "#333333" }).value; + valueLabelColor = colorResolver.text({ fallback: "#333333" }).value; + dimLabelAnchor = "start"; + valueLabelAnchor = "start"; + lineStartX = valueLabelX + currentValueLabelWidth; + + } else if (barWidthValue < totalIconDimSpace) { + // 策略2：图标内部，文本外部 + iconX = textPadding; + dimLabelX = barWidthValue + textPadding; + valueLabelX = dimLabelX + currentDimLabelWidth + 15; + + dimLabelColor = colorResolver.text({ fallback: "#333333" }).value; + valueLabelColor = colorResolver.text({ fallback: "#333333" }).value; + dimLabelAnchor = "start"; + valueLabelAnchor = "start"; + lineStartX = valueLabelX + currentValueLabelWidth; + + } else { + // 策略3：图标和维度标签内部，检查数值标签 + iconX = textPadding; + dimLabelX = iconX + iconSize + textPadding; + dimLabelColor = colorResolver.text({ fallback: "#333333" }).value; + dimLabelAnchor = "start"; + + if (barWidthValue >= totalInsideSpace) { + // 策略3a：所有元素内部 + valueLabelX = barWidthValue - textPadding; + valueLabelColor = "#FFFFFF"; + valueLabelAnchor = "end"; + lineStartX = barWidthValue; + } else { + // 策略3b：数值标签外部 + valueLabelX = barWidthValue + textPadding; + valueLabelColor = colorResolver.text({ fallback: "#333333" }).value; + valueLabelAnchor = "start"; + lineStartX = valueLabelX + currentValueLabelWidth; + } + } + + // 1. 绘制条形 (barRadius was defined above) + g.append("path") + .attr("d", () => { + // Always draw the bar with the rounded right corner + // The clip path will handle cases where barWidthValue < barRadius + const pathData = ` + M 0,${y} + L ${barWidthValue - barRadius},${y} + A ${barRadius},${barRadius} 0 0,1 ${barWidthValue},${centerY} + A ${barRadius},${barRadius} 0 0,1 ${barWidthValue - barRadius},${y + barHeight} + L 0,${y + barHeight} + Z + `; + return pathData; + }) + .attr("fill", getBarColor(dimension)) + .attr("opacity", 0.9) + .attr("clip-path", `url(#${clipPathId})`); // Apply the clip path + + // 2. 添加国家/地区标签和图标 (using calculated positions) + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); + + if (images.field && images.field[dimension]) { + const clipRadius = (flagHeight/2) * 0.8; + const clipId = `clip-${dimension.replace(/\s+/g, '-').toLowerCase()}-${index}`; + const defs = g.append("defs"); + defs.append("clipPath") + .attr("id", clipId) + .append("circle") + .attr("cx", flagWidth/2) + .attr("cy", flagHeight/2) + .attr("r", clipRadius - 2); + + // Border Circle (always add, even if image is missing, for consistency? Maybe not) + iconGroup.append("circle") + .attr("cx", flagWidth/2) + .attr("cy", flagHeight/2) + .attr("r", clipRadius) + .attr("fill", "none") + .attr("stroke", "#000000") // Keep border consistent + .attr("stroke-width", 2); + + // Clipped Image + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]) + .attr("clip-path", `url(#${clipId})`); + } + // Dimension Label (Country Name) + g.append("text") + .attr("x", dimLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", dimLabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", dimLabelColor) + .text(dimensionLabelText); + + // 3. 添加条形数值标签 (Percentage) + const valueLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + g.append("text") + .attr("x", valueLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", valueLabelFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelColor) + .text(valueLabelText); + + // 4. 绘制圆形 (Nominal GDP) + const circleRadius = radiusScale(+dataPoint[valueField2]); + const circleX = barChartWidth + circleChartWidth / 2; + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", getCircleColor(dimension)) + .attr("opacity", 0.6); + + // 5. 添加圆形数值标签 (GDP Value) + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + const circleLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", circleLabelFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + // 6. 添加连接线 - using calculated lineStartX + const lineColor = colorResolver.available(index, { cycle: true, fallback: colorResolver.other("primary", { fallback: "#83C341" }).value }).value; + const lineEndX = circleX - circleRadius; + + if (lineStartX < lineEndX - 1) { + g.append("line") + .attr("x1", lineStartX) + .attr("y1", centerY) + .attr("x2", lineEndX) + .attr("y2", centerY) + .attr("stroke", lineColor) + .attr("stroke-width", 0.8); + } + } catch (error) { + console.error(`渲染${dimension}时出错:`, error); + } + }); + + // 移除临时SVG元素 + tempTextSvg.remove(); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_14.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_14.js new file mode 100644 index 0000000000000000000000000000000000000000..d6b0a263113681c3dfd3f112140835b333978f6e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_14.js @@ -0,0 +1,736 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_14", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["radius_corner", "spacing", "shadow", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js horizontal bar proportional circle area chart 02 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); +     // ---------- 1. 数据准备阶段 ---------- +     +     // 提取数据和配置 +     const jsonData = data;                           // 完整的JSON数据对象 +     const chartData = jsonData.data.data                 // 实际数据点数组   +     const variables = jsonData.variables || {};      // 图表配置 +     const typography = jsonData.typography || {      // 字体设置，如果不存在则使用默认值 +         title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, +         label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, +         description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, +         annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } +     }; +     const colors = jsonData.colors || { +         text_color: "#000000", +         background_color: "#FFFFFF", +         other: { primary: "#83C341" } +     }; +     const images = jsonData.images || { field: {}, other: {} };   // 图像设置 +     const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 +     const titles = jsonData.titles || {};           // 标题配置 +     +     // 设置视觉效果变量的默认值 +     variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : false; +     variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; +     variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; +     variables.has_gradient = variables.has_gradient !== undefined ? variables.has_gradient : false; +     variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; +     +     // 清空容器 +     d3.select(containerSelector).html(""); +     +     // ---------- 2. 尺寸和布局设置 ---------- +     +     // 设置图表总尺寸 +     const width = variables.width || 800; +     const height = variables.height || 600; +     +     // 设置边距 +     const margin = { +         top: 100,      // 顶部留出标题空间 +         right: 5,      // 右侧边距 +         bottom: 40,    // 底部边距 +         left: 10       // 左侧边距，给文字留出一些空间 +     }; +     +     // ---------- 3. 提取字段名和单位 ---------- +     +     // 根据数据列提取字段名 +     const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; +     const valueField1 = chartUtils.schema.channel(jsonData, "y", { fallbackKey: "Crypto Ownership Percentage" }).key || "Crypto Ownership Percentage"; +     const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; +     +     // 获取字段单位 +     let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : +                        chartUtils.schema.channel(jsonData, "y").unit; +     let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : +                        chartUtils.schema.channel(jsonData, "y2").unit; +     valueUnit1 = valueUnit1 ? valueUnit1 : ""; +     valueUnit2 = valueUnit2 ? valueUnit2 : ""; +     +     // 列标题（使用数据列的name字段，而不是description） +     const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || +                           "Crypto Ownership Percentage"; +     const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || +                           "Number of Owners"; +     +     // ---------- 4. 数据处理 ---------- +     +     // 按第一个数值字段降序排序数据 +     const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); +     const sortedDimensions = sortedData.map(d => d[dimensionField]); +     +     // 添加数值格式化函数 +     +     // ---------- 5. 布局计算 ---------- +     +     // 设置条形图和圆形图的布局比例 +     const leftColumnRatio = 0.85;  // 左列占比 +     const rightColumnRatio = 0.15; // 右列占比 +     +     // 计算内部绘图区域尺寸 +     const innerWidth = width - margin.left - margin.right; +     const innerHeight = height - margin.top - margin.bottom; +     +     // 计算两列的宽度 +     const barChartWidth = innerWidth * leftColumnRatio; +     const circleChartWidth = innerWidth * rightColumnRatio; +     +     // ---------- 6. 创建比例尺 ---------- +     +     // 计算条形的额外间距（如果启用） +     const barPadding = variables.has_spacing ? 0.2 : 0.1; +     +     // Y轴比例尺（用于维度） +     const yScale = d3.scaleBand() +         .domain(sortedDimensions) +         .range([0, innerHeight]) +         .padding(barPadding); +     +     // X轴比例尺（用于第一个数值）- 条形图 +     const xScale = d3.scaleLinear() +         .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 +         .range([0, barChartWidth]); +     +     // 圆形面积比例尺（用于第二个数值） +     const maxValue2 = d3.max(chartData, d => +d[valueField2]); +     const minRadius = yScale.bandwidth() * 0.1;  // 最小半径 + // 最大半径限制在条形高度的一半和右侧列宽的一半之间取较小值 +     const maxRadius = Math.min(yScale.bandwidth() * 0.5, circleChartWidth * 0.4); // 稍微缩小一点以防边缘碰撞 +     +     const radiusScale = d3.scaleSqrt()  // 使用平方根比例尺确保面积比例正确 +         .domain([0, maxValue2]) +         .range([minRadius, maxRadius]); +     +     // ---------- 7. 创建SVG容器 ---------- +     +     const svg = d3.select(containerSelector) +         .append("svg") +         .attr("width", "100%") +         .attr("height", height) +         .attr("viewBox", `0 0 ${width} ${height}`) +         .attr("style", "max-width: 100%; height: auto;") +         .attr("xmlns", "http://www.w3.org/2000/svg") +         .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); +     + // ---------- Temporary SVG for text measurement (for titles) ---------- + const tempTextSvgForTitles = svg.append("g").attr("visibility", "hidden"); + + // ---------- Helper: Estimate Generic Text Width (for titles) ---------- + const estimateGenericTextWidth_forTitles = (text, fontConfig) => { + return chartUtils.text.measure(tempTextSvgForTitles, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- Helper: Get Wrapped Lines (for titles) ---------- + function getWrappedLines_forTitles(textContent, availableWidth, fontConfig) { + const words = (textContent || "").trim().split(/\s+/).filter(w => w !== ""); + const lines = []; + const fontSizeValue = parseFloat(fontConfig.font_size); + const lineHeight = fontSizeValue * 1.2; // Estimate line height + + if (words.length === 0) { + return { linesArray: [], numLines: 0, lineHeight: lineHeight }; + } + + let currentLine = words[0]; + if (words.length === 1) { + if (estimateGenericTextWidth_forTitles(currentLine, fontConfig) > availableWidth) { + // Attempt to break the single word if it's too long + let tempLine = ""; + for (let char of currentLine) { + if (estimateGenericTextWidth_forTitles(tempLine + char, fontConfig) > availableWidth && tempLine !== "") { + lines.push(tempLine); + tempLine = char; + } else { + tempLine += char; + } + } + if (tempLine !== "") lines.push(tempLine); + if (lines.length === 0 && currentLine !== "") lines.push(currentLine); // Fallback for very short availableWidth + } else { + lines.push(currentLine); + } + return { linesArray: lines, numLines: lines.length, lineHeight: lineHeight }; + } + + // For multiple words + for (let i = 1; i < words.length; i++) { + const word = words[i]; + const testLine = currentLine + " " + word; + if (estimateGenericTextWidth_forTitles(testLine, fontConfig) > availableWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + if (currentLine !== "") { // Add the last line + // Check if the last line (which could be a single word) itself needs breaking + if (estimateGenericTextWidth_forTitles(currentLine, fontConfig) > availableWidth && !currentLine.includes(" ")) { + let tempLine = ""; + for (let char of currentLine) { + if (estimateGenericTextWidth_forTitles(tempLine + char, fontConfig) > availableWidth && tempLine !== "") { + lines.push(tempLine); + tempLine = char; + } else { + tempLine += char; + } + } + if (tempLine !== "") lines.push(tempLine); + if (lines.length === 0 && currentLine !== "") lines.push(currentLine); + } else if (estimateGenericTextWidth_forTitles(currentLine, fontConfig) > availableWidth && currentLine.includes(" ")) { + // Re-process the last line as if it's a new text to wrap (if it's multi-word but still too long) + const subWrapped = getWrappedLines_forTitles(currentLine, availableWidth, fontConfig); + lines.push(...subWrapped.linesArray); + } + else { + lines.push(currentLine); + } + } + + return { linesArray: lines.filter(l => l.length > 0), numLines: lines.filter(l => l.length > 0).length, lineHeight: lineHeight }; + } + +     // ---------- 8. 添加SVG定义 ---------- +     +     // 添加defs用于视觉效果 +     const defs = svg.append("defs"); +     +     // 添加阴影滤镜（如果启用） +     if (variables.has_shadow) { +         const filter = defs.append("filter") +             .attr("id", "shadow") +             .attr("filterUnits", "userSpaceOnUse") +             .attr("width", "200%") // 增加滤镜区域以包含阴影 +             .attr("height", "200%"); +         +         filter.append("feGaussianBlur") +             .attr("in", "SourceAlpha") +             .attr("stdDeviation", 3) // 阴影模糊度 +             .attr("result", "blur"); +         +         filter.append("feOffset") +             .attr("in", "blur") // 输入为模糊后的图像 +             .attr("dx", 2) // 水平偏移 +             .attr("dy", 2) // 垂直偏移 +             .attr("result", "offsetBlur"); +         +         const feMerge = filter.append("feMerge"); +         feMerge.append("feMergeNode") // 添加阴影层 +             .attr("in", "offsetBlur"); +         feMerge.append("feMergeNode") // 添加原始图形层（置于顶层） +             .attr("in", "SourceGraphic"); +     } +     +     // 为每个维度创建渐变（如果启用） +     if (variables.has_gradient) { +         sortedDimensions.forEach(dimension => { +             const barColor = getBarColor(dimension); +             +             const gradient = defs.append("linearGradient") +                 .attr("id", `bar-gradient-${dimension.replace(/\s+/g, '-')}`) +                 .attr("x1", "0%") +                 .attr("y1", "0%") +                 .attr("x2", "100%") // 水平渐变 +                 .attr("y2", "0%"); +             +             gradient.append("stop") +                 .attr("offset", "0%") +                 .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 0.5 })); // 渐变起始颜色（较亮） +             +             gradient.append("stop") +                 .attr("offset", "100%") +                 .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); // 渐变结束颜色（较暗） +         }); +     } +     +     // ---------- 9. 添加标题和标题下的线条 ---------- +     +     // 计算标题位置 - Refactored for wrapping +     const titleFontConfig = typography.description; +     const titleTextBottomMargin = 15; // Space between title text's last line and the decorative line + const decorativeLineY = margin.top - titleTextBottomMargin; // Y position of the decorative line +     const desiredBaselineOfLastTitleLine = decorativeLineY - 5; // Baseline of the last line of title text (5px above the decorative line) +     +     // 左侧列标题 +     const leftTitleAvailableWidth = innerWidth * 0.6; +     const leftTitleXPos = margin.left; + const columnTitle1Upper = columnTitle1.toUpperCase(); +     const wrappedLeftTitle = getWrappedLines_forTitles(columnTitle1Upper, leftTitleAvailableWidth, titleFontConfig); +     +     if (wrappedLeftTitle.numLines > 0) { +         const initialYLeft = desiredBaselineOfLastTitleLine - (wrappedLeftTitle.numLines - 1) * wrappedLeftTitle.lineHeight; +         const leftTitleText = svg.append("text") +             .attr("x", leftTitleXPos) +             .attr("y", initialYLeft) +             .attr("text-anchor", "start") +             .style("font-family", titleFontConfig.font_family) +             .style("font-size", titleFontConfig.font_size) +             .style("font-weight", titleFontConfig.font_weight) +             .style("fill", colorResolver.text({ fallback: "#333333" }).value); + +         wrappedLeftTitle.linesArray.forEach((line, i) => { +             leftTitleText.append("tspan") +                 .attr("x", leftTitleXPos) +                 .attr("dy", i === 0 ? 0 : wrappedLeftTitle.lineHeight) +                 .text(line); +         }); +     } + +     // 右侧列标题 +     const rightTitleAvailableWidth = innerWidth * 0.4; +     const rightTitleXPos = width - margin.right; // Align to the right edge of the chart + const columnTitle2Upper = columnTitle2.toUpperCase(); +     const wrappedRightTitle = getWrappedLines_forTitles(columnTitle2Upper, rightTitleAvailableWidth, titleFontConfig); + +     if (wrappedRightTitle.numLines > 0) { +         const initialYRight = desiredBaselineOfLastTitleLine - (wrappedRightTitle.numLines - 1) * wrappedRightTitle.lineHeight; +         const rightTitleText = svg.append("text") +             .attr("x", rightTitleXPos) +             .attr("y", initialYRight) +             .attr("text-anchor", "end") // Right-align +             .style("font-family", titleFontConfig.font_family) +             .style("font-size", titleFontConfig.font_size) +             .style("font-weight", titleFontConfig.font_weight) +             .style("fill", colorResolver.text({ fallback: "#333333" }).value); + +         wrappedRightTitle.linesArray.forEach((line, i) => { +             rightTitleText.append("tspan") +                 .attr("x", rightTitleXPos) +                 .attr("dy", i === 0 ? 0 : wrappedRightTitle.lineHeight) +                 .text(line); +         }); +     } + +     // 标题下的黑线 (Adjusted Y position) +     svg.append("line") +         .attr("x1", margin.left) +         .attr("y1", decorativeLineY) +         .attr("x2", width - margin.right) +         .attr("y2", decorativeLineY) +         .attr("stroke", "#000000") +         .attr("stroke-width", 1.5); +     +     // 左侧标题下的三角形 (Adjusted X and Y position) + const leftTriangleCenterX = margin.left + leftTitleAvailableWidth / 2; +     svg.append("polygon") +         .attr("points", `${leftTriangleCenterX - 6},${decorativeLineY + 1} ${leftTriangleCenterX + 6},${decorativeLineY + 1} ${leftTriangleCenterX},${decorativeLineY + 8}`) +         .attr("fill", "#000000"); +     +     // 右侧标题下的三角形 (Adjusted X and Y position) + const rightTriangleCenterX = (margin.left + leftTitleAvailableWidth) + (rightTitleAvailableWidth / 2); +     svg.append("polygon") +         .attr("points", `${rightTriangleCenterX - 6},${decorativeLineY + 1} ${rightTriangleCenterX + 6},${decorativeLineY + 1} ${rightTriangleCenterX},${decorativeLineY + 8}`) +         .attr("fill", "#000000"); +     + // Remove the temporary SVG element for title measurement once done with titles + tempTextSvgForTitles.remove(); + +     // ---------- 10. 创建主图表组 ---------- +     +     const g = svg.append("g") +         .attr("transform", `translate(${margin.left}, ${margin.top})`); // 应用边距 +     +     // ---------- 11. 获取条形图颜色的辅助函数 ---------- +     +     // 获取条形图颜色 +     const getBarColor = (dimension) => { +         // 优先使用字段特定颜色 +         if (colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value) { +             return colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value; +         } +         // 否则使用主要的备用颜色 +         return colorResolver.other("primary", { fallback: "#83C341" }).value; // 使用可选链和默认值增加健壮性 +     }; +     +     // ---------- 12. 绘制所有圆形（先绘制，以免被条形覆盖，确保阴影等效果完整）---------- + // 注意：这里只绘制圆形本身，标签将在后面的循环中添加 +     sortedDimensions.forEach((dimension, index) => { +         const dataPoint = chartData.find(d => d[dimensionField] === dimension); +         if (!dataPoint || isNaN(+dataPoint[valueField2])) return; // 跳过无效数据 +         +         const barHeight = yScale.bandwidth(); +         const y = yScale(dimension); +         const centerY = y + barHeight / 2; +         +         // 绘制圆形（应用视觉效果） +         const circleRadius = radiusScale(+dataPoint[valueField2]); + // 圆心X坐标位于右侧列的中心 +         const circleX = barChartWidth + circleChartWidth / 2; +         +         g.append("circle") +             .attr("cx", circleX) +             .attr("cy", centerY) +             .attr("r", Math.max(0, circleRadius)) // 确保半径不为负 +             .attr("fill", getBarColor(dimension)) +             .style("stroke", variables.has_stroke ? colorResolver.variant(getBarColor(dimension), { mode: "darker", amount: 0.5 }) : "none") // 添加描边（如果启用） +             .style("stroke-width", variables.has_stroke ? 1.5 : 0) // 描边宽度 +             .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); // 应用阴影（如果启用） +     }); +     +     // ---------- 13. 为每个维度绘制条形、标签和连接线 ---------- +     +     // Helper function for text wrapping (can be defined here as it uses measureTextWidth from the loop's scope) + function getWrappedLines_local(text, maxWidth, style, getTextWidthFunc) { + const words = text.split(/\s+/).filter(w => w.length > 0); + const lines = []; + + if (words.length === 0) return [""]; // Return an empty string in an array if no words + + // Helper to wrap a single word if it's too long + const wrapSingleWord = (singleWord) => { + const wordLines = []; + let currentWordPart = ""; + for (let char of singleWord) { + if (getTextWidthFunc(currentWordPart + char, style) > maxWidth && currentWordPart !== "") { + wordLines.push(currentWordPart); + currentWordPart = char; + } else { + currentWordPart += char; + } + } + if (currentWordPart !== "") wordLines.push(currentWordPart); + return wordLines.length > 0 ? wordLines : [singleWord]; // Fallback to original word if wrapping fails + }; + + if (words.length === 1) { + if (getTextWidthFunc(words[0], style) > maxWidth) { + return wrapSingleWord(words[0]); + } else { + return [words[0]]; + } + } + + let currentLine = words[0]; + // Check if the first word itself is too long + if (getTextWidthFunc(currentLine, style) > maxWidth) { + const wrappedFirstWordLines = wrapSingleWord(currentLine); + lines.push(...wrappedFirstWordLines.slice(0, -1)); + currentLine = wrappedFirstWordLines.length > 0 ? wrappedFirstWordLines[wrappedFirstWordLines.length - 1] : ""; + if (currentLine === "" && words.length > 1) currentLine = words[1]; // Move to next word if first was fully consumed and broken + else if (currentLine === "" && words.length ===1) { lines.push(...wrapSingleWord(words[0])); return lines.filter(l => l!="");} + + + } + + + for (let i = 1; i < words.length; i++) { + const word = words[i]; + // First check if the current word itself is too long + if (getTextWidthFunc(word, style) > maxWidth) { + if (currentLine !== "") lines.push(currentLine); // Push the line before this long word + lines.push(...wrapSingleWord(word)); // Push the wrapped parts of the long word + currentLine = ""; // Reset currentLine + continue; + } + + const testLine = currentLine === "" ? word : currentLine + " " + word; + if (getTextWidthFunc(testLine, style) > maxWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + + if (currentLine !== "") { // Add the last line + if (getTextWidthFunc(currentLine, style) > maxWidth && !currentLine.includes(" ") ) { // Single long word as last line + lines.push(...wrapSingleWord(currentLine)); + } else if (getTextWidthFunc(currentLine, style) > maxWidth && currentLine.includes(" ")) { // Last line has multiple words but still too long (edge case after loop logic) + // Re-process the last line as if it's a new text to wrap + const subLines = getWrappedLines_local(currentLine, maxWidth, style, getTextWidthFunc); + lines.push(...subLines); + } + else { + lines.push(currentLine); + } + } + return lines.filter(l => l !== ""); // Ensure no empty lines + } +     +     sortedDimensions.forEach((dimension, index) => { +         try { +             const dataPoint = chartData.find(d => d[dimensionField] === dimension); +             +             if (!dataPoint) { +                 console.warn(`No data found for dimension: ${dimension}`); // 使用warn而不是error +                 return; // 继续下一个循环 +             } +             +             // 检查数据值是否有效 +             if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { +                 console.warn(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); +                 return; // 继续下一个循环 +             } +             +             const barHeight = yScale.bandwidth(); +             const y = yScale(dimension); +             if (typeof y !== 'number') { // 检查yScale返回是否有效 +                 console.warn(`Invalid y position for dimension: ${dimension}`); +                 return; // 继续下一个循环 +             } +             +             const centerY = y + barHeight / 2; // 条形和圆形的中心Y坐标 +             const barWidthValue = xScale(+dataPoint[valueField1]); // 计算条形宽度 + const labelPadding = 5; // 标签与元素之间的通用内边距/外边距 + const labelPaddingInside = 10; // 标签在条形内部时的左右内边距 + const countryTextOriginal = dimension; // Keep original case for data, use uppercase for display if needed + const value1Text = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; // 第一个数值的文本 + const value2Text = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; // 第二个数值的文本 +             +             // 1. 绘制条形（应用视觉效果） +             const barFill = variables.has_gradient +                 ? `url(#bar-gradient-${dimension.replace(/\s+/g, '-')})` // 使用渐变填充（如果启用） +                 : getBarColor(dimension); // 使用纯色填充 +                 +             g.append("rect") +                 .attr("x", 0) +                 .attr("y", y) +                 .attr("width", Math.max(0, barWidthValue)) // 确保宽度不为负 +                 .attr("height", barHeight) +                 .attr("fill", barFill) +                 .attr("rx", variables.has_rounded_corners ? barHeight * 0.2 : 0) // 圆角（如果启用） +                 .attr("ry", variables.has_rounded_corners ? barHeight * 0.2 : 0) // 圆角（如果启用） +                 .style("stroke", variables.has_stroke ? colorResolver.variant(getBarColor(dimension), { mode: "darker", amount: 0.5 }) : "none") // 描边（如果启用） +                 .style("stroke-width", variables.has_stroke ? 1.5 : 0) // 描边宽度 +                 .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); // 阴影（如果启用） + + // --- 标签定位逻辑 --- + + // Helper to measure text width (already defined in outer scope by user, but ensuring it's clear) + const measureTextWidth = (text, style) => { + return chartUtils.text.measure(g, text, { fontFamily: style.font_family, fontSize: parseFloat(style.font_size) || style.font_size, fontWeight: style.font_weight }).width; + }; + + // --- Dimension Label (countryText) Processing --- + const countryTextForDisplay = countryTextOriginal.toUpperCase(); + const maxAllowedDimLabelWidth = innerWidth * 0.3; + let finalDimFontSize = parseFloat(typography.label.font_size); + let currentDimLabelWidth = measureTextWidth(countryTextForDisplay, { ...typography.label, font_size: `${finalDimFontSize}px` }); + + if (currentDimLabelWidth > maxAllowedDimLabelWidth) { + let tempSize = finalDimFontSize; + while (tempSize > 8) { // Min font size 8px + tempSize--; + const tempWidth = measureTextWidth(countryTextForDisplay, { ...typography.label, font_size: `${tempSize}px` }); + if (tempWidth <= maxAllowedDimLabelWidth) { + break; + } + } + finalDimFontSize = tempSize; + currentDimLabelWidth = measureTextWidth(countryTextForDisplay, { ...typography.label, font_size: `${finalDimFontSize}px` }); + } + + const finalDimLabelStyle = { + ...typography.label, + font_size: `${finalDimFontSize}px` + }; + + let dimLabelLines = [countryTextForDisplay]; + let dimLabelIsWrapped = false; + let dimLabelEffectiveWidth = currentDimLabelWidth; // Width after font reduction + + if (currentDimLabelWidth > maxAllowedDimLabelWidth) { // Still too wide, so wrap + dimLabelIsWrapped = true; + dimLabelLines = getWrappedLines_local(countryTextForDisplay, maxAllowedDimLabelWidth, finalDimLabelStyle, measureTextWidth); + // Recalculate effective width based on the longest wrapped line + let maxWidthOfWrappedLine = 0; + dimLabelLines.forEach(line => { + const lineWidth = measureTextWidth(line, finalDimLabelStyle); + if (lineWidth > maxWidthOfWrappedLine) maxWidthOfWrappedLine = lineWidth; + }); + dimLabelEffectiveWidth = maxWidthOfWrappedLine > 0 ? maxWidthOfWrappedLine : maxAllowedDimLabelWidth; // Use measured if available + } + + let dimLabelX, dimLabelColor, dimLabelAnchor; + let dimLabelEndPosX; + + if (!dimLabelIsWrapped && barWidthValue >= labelPaddingInside + dimLabelEffectiveWidth + labelPaddingInside) { + dimLabelX = labelPaddingInside; + dimLabelColor = "#FFFFFF"; + dimLabelAnchor = "start"; + dimLabelEndPosX = dimLabelX + dimLabelEffectiveWidth; + } else { + dimLabelX = barWidthValue + labelPadding; + dimLabelColor = colorResolver.text({ fallback: "#333333" }).value; + dimLabelAnchor = "start"; + dimLabelEndPosX = dimLabelX + dimLabelEffectiveWidth; + } + + // Render Dimension Label + const dimLabelLineHeight = parseFloat(finalDimLabelStyle.font_size) * 1.2; + const totalDimLabelHeight = dimLabelLines.length * dimLabelLineHeight; + const firstDimLineY = centerY - (totalDimLabelHeight / 2) + (dimLabelLineHeight / 2); + + const dimTextElement = g.append("text") + .attr("y", firstDimLineY) + .attr("text-anchor", dimLabelAnchor) + .style("font-family", finalDimLabelStyle.font_family) + .style("font-size", finalDimLabelStyle.font_size) + .style("font-weight", finalDimLabelStyle.font_weight) + .style("fill", dimLabelColor); + + dimLabelLines.forEach((line, i) => { + dimTextElement.append("tspan") + .attr("x", dimLabelX) // X is set per tspan for consistent alignment + .attr("dy", i === 0 ? 0 : dimLabelLineHeight) + .text(line); + }); + + // --- Value 1 Label (Percentage) Processing --- + const value1LabelStyle = typography.label; // Assuming value1 uses standard label typography + const value1LabelWidth = measureTextWidth(value1Text, value1LabelStyle); + + let value1LabelX, value1LabelColor, value1LabelAnchor; + let value1LabelEndPos; + + // Check if dimension label is effectively inside the bar for positioning value1 + const isDimLabelInsideBar = (dimLabelX === labelPaddingInside); + + if (isDimLabelInsideBar) { + if (barWidthValue >= dimLabelEndPosX + labelPadding + value1LabelWidth + labelPaddingInside) { + value1LabelX = barWidthValue - labelPaddingInside; + value1LabelColor = "#FFFFFF"; + value1LabelAnchor = "end"; + value1LabelEndPos = barWidthValue; + } else { + value1LabelX = barWidthValue + labelPadding; + value1LabelColor = colorResolver.text({ fallback: "#333333" }).value; + value1LabelAnchor = "start"; + value1LabelEndPos = value1LabelX + value1LabelWidth; + } + } else { + value1LabelX = dimLabelEndPosX + labelPadding; + value1LabelColor = colorResolver.text({ fallback: "#333333" }).value; + value1LabelAnchor = "start"; + value1LabelEndPos = value1LabelX + value1LabelWidth; + } + + // Render Value 1 Label + g.append("text") + .attr("x", value1LabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", value1LabelAnchor) + .style("font-family", value1LabelStyle.font_family) + .style("font-size", value1LabelStyle.font_size) + .style("font-weight", value1LabelStyle.font_weight) + .style("fill", value1LabelColor) + .text(value1Text); + +             // 4. 添加圆形数值标签 (Value 2) +             const circleRadius = radiusScale(+dataPoint[valueField2]); + // 圆心X坐标在右侧列的中心 +             const circleX = barChartWidth + circleChartWidth / 2; + let value2LabelX, value2LabelY, value2LabelColor, value2LabelAnchor, value2LabelDy; + const value2LabelWidth = measureTextWidth(value2Text, typography.label); // Re-measure for value2 + + // 判断文本宽度是否小于圆的直径 (留一些边距) + if (circleRadius * 2 > value2LabelWidth + labelPadding * 2) { + // 空间足够，文本放在圆内，白色 + value2LabelX = circleX; + value2LabelY = centerY; + value2LabelColor = "#FFFFFF"; + value2LabelAnchor = "middle"; + value2LabelDy = "0.35em"; // 垂直居中 + } else { + // 空间不足，文本放在圆上方，与圆相同颜色 + value2LabelX = circleX; + value2LabelY = centerY - circleRadius - labelPadding; // 圆顶上方加一点间距 + value2LabelColor = getBarColor(dimension); // 使用圆的颜色 + value2LabelAnchor = "middle"; + value2LabelDy = "0em"; // 基线对齐 + // 如果标签放在上方后低于图表顶部标题线，则尝试放在下方 + if (value2LabelY - (parseFloat(typography.label.font_size)/2) < -(margin.top - decorativeLineY -10) ){ // -margin.top是g元素的顶部，decorativeLineY是线的位置 + value2LabelY = centerY + circleRadius + labelPadding + parseFloat(typography.label.font_size); // 圆底下方加间距和字体高度 + value2LabelDy = "0.8em"; // 调整基线使文本看起来在圆下方 + } + } + + g.append("text") + .attr("x", value2LabelX) + .attr("y", value2LabelY) + .attr("dy", value2LabelDy) + .attr("text-anchor", value2LabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", value2LabelColor) + .text(value2Text); + + // 5. 添加连接线 - 从条形图（或标签）到圆形 + const lineColor = getBarColor(dimension); // 线条颜色与条形/圆形一致 + + // 确定线的起始X坐标：应在数值1标签的右侧结束位置之后 + const lineStartX = value1LabelEndPos + labelPadding; + +             // 计算线的终点X坐标（圆的左边缘） +             const lineEndX = circleX - circleRadius; +             + // 只有当起始点在结束点左侧时才绘制线 + if (lineStartX < lineEndX - 1) { // 减1避免绘制极短的线 +             // 绘制连接线 +             g.append("line") +                 .attr("x1", lineStartX) +                 .attr("y1", centerY) +                 .attr("x2", lineEndX) +                 .attr("y2", centerY) +                 .attr("stroke", lineColor) +                 .attr("stroke-width", 0.8); // 线条粗细 + } +             +         } catch (error) { +             console.error(`Error rendering chart element for ${dimension}:`, error); +             // 继续处理下一个元素，而不是停止整个图表渲染 +         } +     }); +     +     // 返回SVG节点 +     return svg.node(); + } diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15.js new file mode 100644 index 0000000000000000000000000000000000000000..f6aa75f9a5e456bdf00679aae4711bf8f2d3c81a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15.js @@ -0,0 +1,444 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_15", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary"], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; + + // 获取实际数据数组 - 处理不同的数据结构形式 + let chartData = []; + if (Array.isArray(jsonData.data)) { + chartData = jsonData.data; + } else if (jsonData.data && Array.isArray(jsonData.data.data)) { + chartData = jsonData.data.data; + } + + // 提取其他配置 + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#4269d0", secondary: "#4269d0" }, + available_colors: ["#4269d0", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5"] + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + const titles = jsonData.titles || {}; + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // ---------- 3. 数据处理 ---------- + + // 按第一个数值字段降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField1] - +a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 4. 文本测量 ---------- + + const labelMeasureOptions = { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }; + + // 4.2 测量每个标签的宽度并找出最大值 + const labelWidths = sortedDimensions.map(d => { + return chartUtils.text.measure(null, d.toUpperCase(), labelMeasureOptions).width; + }); + + // 4.3 测量数值标签的最大宽度 + const valueWidths = sortedData.map(d => { + return chartUtils.text.measure(null, `${chartUtils.format.autoText(+d[valueField1])}${valueUnit1}`, labelMeasureOptions).width; + }); + + // 4.4 测量第二个数值标签的最大宽度 + const value2Widths = sortedData.map(d => { + return chartUtils.text.measure(null, `${chartUtils.format.autoText(+d[valueField2])}${valueUnit2}`, labelMeasureOptions).width; + }); + + const maxLabelWidth = Math.max(...labelWidths); + const maxValueWidth = Math.max(...valueWidths); + const maxValue2Width = Math.max(...value2Widths); + // ---------- 5. 尺寸和布局设置 ---------- + + // 图标尺寸 + const flagWidth = 24; + const flagHeight = 24; + const flagMargin = 10; + const textIconGap = 10; // 标签文本和图标之间的间距 + const valueLabelGap = 5; // 条形和值标签之间的间距 + + // 基于内容计算合适的图表总宽度 + const leftSectionWidth = maxLabelWidth + flagWidth + flagMargin + textIconGap; + + // 设置图表总尺寸 + const minWidth = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 20, // 大幅增加右侧边距，确保圆形完全显示 + bottom: 60, // 底部边距 + left: Math.max(20, leftSectionWidth + 20) // 确保左侧边距足够容纳标签和图标 + }; + + // 计算内部绘图区域尺寸 + const innerWidth = minWidth - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 设置条形图和圆形图的分配比例 - 条形图占更多空间 + const barChartRatio = 0.8; + const circleChartRatio = 0.2; + + // 计算条形图的最大宽度，保证值标签显示 + const barChartWidth = innerWidth * barChartRatio - maxValueWidth - valueLabelGap; + + // 计算圆形图部分的宽度 + const circleChartWidth = innerWidth * circleChartRatio; + + // 计算圆形的最大直径，确保不溢出右侧边距 + const maxCircleDiameter = Math.min(circleChartWidth * 0.8, 80); + + // 计算实际总宽度 + const width = margin.left + barChartWidth + maxValueWidth + valueLabelGap + circleChartWidth + margin.right; + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距 + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // 条形高度 + const barHeight = yScale.bandwidth(); + + // X轴比例尺（用于第一个数值）- 条形图 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barChartWidth]); + + // 圆形面积比例尺（用于第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + + // 计算最小和最大半径 + const minRadius = Math.min(barHeight * 0.4, maxCircleDiameter * 0.2); + const maxRadius = Math.min(barHeight * (1 + barPadding/2), maxCircleDiameter/2); + + const radiusScale = d3.scaleSqrt() + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 8. 添加标题 ---------- + + // 获取条形图颜色和圆形图颜色用于图例 + const barColor = colorResolver.field(valueField1, 0, { fallbackKey: "primary" }).value; + + const circleColor = colorResolver.field(valueField2, 0, { fallbackKey: "secondary" }).value; + + // 标题宽度是总宽度的一半 + const titleWidth = width / 2; + + // 设置图例大小和间距 + const legendSize = 16; // 图例方块/圆形大小 + const legendMargin = 8; // 图例与文本间距 + const legendTextOffset = legendSize + legendMargin; // 文本起始位置偏移 + + // 修改：左侧列标题 - 左对齐，占据图表一半宽度，支持自动换行 + const leftTitleGroup = svg.append("g") + .attr("transform", `translate(0, ${margin.top - 30})`); + + // 添加方形图例 + leftTitleGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", legendSize) + .attr("height", legendSize) + .attr("fill", barColor); + + const leftTitle = leftTitleGroup.append("text") + .attr("x", legendTextOffset) // 从图例右侧开始 + .attr("y", legendSize / 2) // 垂直居中对齐文本 + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 为长文本实现换行 + wrapText(leftTitle, columnTitle1, titleWidth - legendTextOffset, 1.2); + + // 修改：右侧列标题 - 右对齐，占据图表一半宽度，圆形图例位于标题文本左侧 + const rightTitleGroup = svg.append("g") + .attr("transform", `translate(0, ${margin.top - 30})`); + + // 首先添加标题文本 - 右对齐到图表右边缘 + const rightTitle = rightTitleGroup.append("text") + .attr("x", width) // 位于图表最右侧 + .attr("y", legendSize / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // 测量文本宽度以便正确放置图例 + const rightTitleWidth = chartUtils.text.measure(rightTitleGroup, columnTitle2, { + fontFamily: typography.description.font_family, + fontSize: typography.description.font_size, + fontWeight: typography.description.font_weight + }).width; + + // 添加圆形图例 - 位于文本左侧 + rightTitleGroup.append("circle") + .attr("cx", width - rightTitleWidth - legendMargin - 5) + .attr("cy", legendSize / 2) + .attr("r", legendSize/2) + .attr("fill", circleColor); + + // 文本换行函数 - 只用于左侧标题，右侧标题现在不需要换行 + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + const textMeasureOptions = { + fontFamily: text.style("font-family") || typography.description.font_family, + fontSize: parseFloat(text.style("font-size")) || parseFloat(typography.description.font_size), + fontWeight: text.style("font-weight") || typography.description.font_weight + }; + const measureTextWidth = value => chartUtils.text.measure(null, value, textMeasureOptions).width; + let tspan = text.text(null).append("tspan") + .attr("x", text.attr("x")) + .attr("y", y) + .attr("dy", dy + "em"); + + while (word = words.pop()) { + line.push(word); + tspan.text(line.join(" ")); + if (measureTextWidth(line.join(" ")) > width) { + line.pop(); + tspan.text(line.join(" ")); + line = [word]; + tspan = text.append("tspan") + .attr("x", text.attr("x")) + .attr("y", y) + .attr("dy", ++lineNumber * lineHeight + dy + "em") + .text(word); + } + } + } + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 获取条形图颜色 + const getBarColor = () => { + return colorResolver.field(valueField1, 0, { fallback: colorResolver.other("primary").value }).value; + }; + + // 获取圆形图颜色 + const getCircleColor = () => { + return colorResolver.field(valueField2, 0, { fallback: colorResolver.other("secondary").value }).value; + }; + + // 为每个维度绘制内容 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const barHeight = yScale.bandwidth(); + const centerY = y + barHeight / 2; + const barWidthValue = xScale(+dataPoint[valueField1]); + + // 1. 添加国家/地区名称 - 右对齐 + // 标签位置在最左侧，右对齐 + const labelX = -flagWidth - flagMargin - textIconGap; + + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 2. 添加国家/地区图标 - 修改：直接使用矩形图标 + if (images.field && images.field[dimension]) { + // 创建一个组来包含图像 + const iconGroup = g.append("g") + .attr("transform", `translate(${-flagWidth - flagMargin}, ${centerY - flagHeight/2})`); + + // 直接添加国家/地区图标，不使用圆形裁剪 + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 3. 绘制条形 - 只使用矩形 + g.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidthValue) + .attr("height", barHeight) + .attr("fill", getBarColor()) + .attr("opacity", 0.9); + + // 4. 添加条形数值标签 + const formattedValue1 = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + + g.append("text") + .attr("x", barWidthValue + valueLabelGap) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue1); + + // 5. 计算圆形位置 + // 确保圆形居中放置 + const circleX = barChartWidth + maxValueWidth + valueLabelGap + circleChartWidth / 2; + const circleRadius = radiusScale(+dataPoint[valueField2]); + + // 绘制圆形 + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", getCircleColor()) + .attr("opacity", 0.7); + + // 6. 添加圆形数值标签 + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + } catch (error) { + console.error(`Error rendering chart element for ${dimension}:`, error); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..c4b799ebcf21def95eed4bb7ee34469b495a5aa9 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_15_hand.js @@ -0,0 +1,483 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_15_hand", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 15], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary"], + "supported_effects": ["radius_corner", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; + + // 获取实际数据数组 - 处理不同的数据结构形式 + let chartData = []; + if (Array.isArray(jsonData.data)) { + chartData = jsonData.data; + } else if (jsonData.data && Array.isArray(jsonData.data.data)) { + chartData = jsonData.data.data; + } + + // 提取其他配置 + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#4269d0", secondary: "#4269d0" }, + available_colors: ["#4269d0", "#6cc5b0", "#3ca951", "#ff8ab7", "#a463f2", "#97bbf5"] + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + const titles = jsonData.titles || {}; + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // ---------- 3. 数据处理 ---------- + + // 按第一个数值字段降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField1] - +a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 4. 文本测量 ---------- + + const labelMeasureOptions = { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }; + + // 4.2 测量每个标签的宽度并找出最大值 + const labelWidths = sortedDimensions.map(d => { + return chartUtils.text.measure(null, d.toUpperCase(), labelMeasureOptions).width; + }); + + // 4.3 测量数值标签的最大宽度 + const valueWidths = sortedData.map(d => { + return chartUtils.text.measure(null, `${chartUtils.format.autoText(+d[valueField1])}${valueUnit1}`, labelMeasureOptions).width; + }); + + // 4.4 测量第二个数值标签的最大宽度 + const value2Widths = sortedData.map(d => { + return chartUtils.text.measure(null, `${chartUtils.format.autoText(+d[valueField2])}${valueUnit2}`, labelMeasureOptions).width; + }); + + const maxLabelWidth = Math.max(...labelWidths); + const maxValueWidth = Math.max(...valueWidths); + const maxValue2Width = Math.max(...value2Widths); + // ---------- 5. 尺寸和布局设置 ---------- + + // 图表尺寸 + const minWidth = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 120, // 顶部留出标题空间 + right: 20, // 右侧边距 + bottom: 60, // 底部边距 + left: 20 // 初始左侧边距 + }; + + // 计算条形高度相关参数 + const MAX_BAR_HEIGHT = 100; // 新增：限制条形最大高度为100px + + // 计算内部绘图区域尺寸 + const innerWidth = minWidth - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 设置条形图和圆形图的分配比例 - 条形图占更多空间 + const barChartRatio = 0.8; + const circleChartRatio = 0.2; + + // 计算条形图的最大宽度，保证值标签显示 + const barChartWidth = innerWidth * barChartRatio - maxValueWidth - 5; + + // 计算圆形图部分的宽度 + const circleChartWidth = innerWidth * circleChartRatio; + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距 + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // 根据数据项数量和最大条形高度计算实际条形高度 + const itemCount = sortedDimensions.length; + const totalBarSpace = innerHeight * (1 - barPadding); // 考虑间距后可用的总空间 + let barHeight = totalBarSpace / itemCount; // 初始计算的每个条形高度 + + // 限制条形最大高度 + barHeight = Math.min(barHeight, MAX_BAR_HEIGHT); + + // 重新计算总图表高度（如果条形高度被限制） + const adjustedInnerHeight = barHeight * itemCount / (1 - barPadding); + const adjustedHeight = adjustedInnerHeight + margin.top + margin.bottom; + + // Y轴比例尺（用于维度）- 使用固定条形高度 + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, adjustedInnerHeight]) + .padding(barPadding); + + // 获取实际的条形高度 + const actualBarHeight = yScale.bandwidth(); + + // 计算图标尺寸 - 新增：根据条形高度动态调整图标大小 + const flagHeight = Math.min(64, actualBarHeight - 8); + const flagWidth = flagHeight; // 保持图标宽高相等 + const flagMargin = 10; + const textIconGap = 10; // 标签文本和图标之间的间距 + const valueLabelGap = 5; // 条形和值标签之间的间距 + + // 基于内容计算合适的图表总宽度 + const leftSectionWidth = maxLabelWidth + flagWidth + flagMargin + textIconGap; + + // 更新左侧边距 + margin.left = Math.max(20, leftSectionWidth + 20); + + // 计算圆形的最大直径，确保不溢出右侧边距 + const maxCircleDiameter = Math.min(circleChartWidth * 0.8, 80); + + // 计算实际总宽度 + const width = margin.left + barChartWidth + maxValueWidth + valueLabelGap + circleChartWidth + margin.right; + + // X轴比例尺（用于第一个数值）- 条形图 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barChartWidth]); + + // 圆形面积比例尺（用于第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + + // 计算最小和最大半径 + const minRadius = Math.min(actualBarHeight * 0.4, maxCircleDiameter * 0.2); + const maxRadius = Math.min(actualBarHeight * (1 + barPadding/2), maxCircleDiameter/2); + + const radiusScale = d3.scaleSqrt() + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", adjustedHeight) // 使用调整后的高度 + .attr("viewBox", `0 0 ${width} ${adjustedHeight}`) // 使用调整后的视图框 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 8. 添加标题 ---------- + + // 获取条形图颜色和圆形图颜色用于图例 + const barColor = colorResolver.field(valueField1, 0, { fallbackKey: "primary" }).value; + + const circleColor = colorResolver.field(valueField2, 0, { fallbackKey: "secondary" }).value; + + // 标题宽度是总宽度的一半 + const titleWidth = width / 2; + + // 设置图例大小和间距 + const legendSize = 28.8; // 图例方块/圆形大小，原来16的1.8倍 + const legendMargin = 8; // 图例与文本间距 + const legendTextOffset = legendSize + legendMargin; // 文本起始位置偏移 + + // 修改：左侧列标题 - 左对齐，占据图表一半宽度，支持自动换行 + const leftTitleGroup = svg.append("g") + .attr("transform", `translate(0, ${margin.top - 30})`); + + // 添加方形图例 + leftTitleGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", legendSize) + .attr("height", legendSize) + .attr("fill", barColor); + + const leftTitle = leftTitleGroup.append("text") + .attr("x", legendTextOffset) // 从图例右侧开始 + .attr("y", legendSize / 2) // 垂直居中对齐文本 + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 为长文本实现换行 + wrapText(leftTitle, columnTitle1, titleWidth - legendTextOffset, 1.2); + + // 修改：右侧列标题 - 右对齐，占据图表一半宽度，圆形图例位于标题文本左侧 + const rightTitleGroup = svg.append("g") + .attr("transform", `translate(0, ${margin.top - 30})`); + + // 首先添加标题文本 - 右对齐到图表右边缘 + const rightTitle = rightTitleGroup.append("text") + .attr("x", width) // 位于图表最右侧 + .attr("y", legendSize / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // 测量文本宽度以便正确放置图例 + const rightTitleWidth = chartUtils.text.measure(rightTitleGroup, columnTitle2, { + fontFamily: typography.description.font_family, + fontSize: typography.description.font_size, + fontWeight: typography.description.font_weight + }).width; + + // 添加圆形图例 - 位于文本左侧 + rightTitleGroup.append("circle") + .attr("cx", width - rightTitleWidth - legendMargin - 5) + .attr("cy", legendSize / 2) + .attr("r", legendSize/2) + .attr("fill", circleColor); + + // 文本换行函数 - 只用于左侧标题，右侧标题现在不需要换行 + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + const textMeasureOptions = { + fontFamily: text.style("font-family") || typography.description.font_family, + fontSize: parseFloat(text.style("font-size")) || parseFloat(typography.description.font_size), + fontWeight: text.style("font-weight") || typography.description.font_weight + }; + const measureTextWidth = value => chartUtils.text.measure(null, value, textMeasureOptions).width; + let tspan = text.text(null).append("tspan") + .attr("x", text.attr("x")) + .attr("y", y) + .attr("dy", dy + "em"); + + while (word = words.pop()) { + line.push(word); + tspan.text(line.join(" ")); + if (measureTextWidth(line.join(" ")) > width) { + line.pop(); + tspan.text(line.join(" ")); + line = [word]; + tspan = text.append("tspan") + .attr("x", text.attr("x")) + .attr("y", y) + .attr("dy", ++lineNumber * lineHeight + dy + "em") + .text(word); + } + } + } + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 获取条形图颜色 + const getBarColor = () => { + return colorResolver.field(valueField1, 0, { fallback: colorResolver.other("primary").value }).value; + }; + + // 获取圆形图颜色 + const getCircleColor = () => { + return colorResolver.field(valueField2, 0, { fallback: colorResolver.other("secondary").value }).value; + }; + + // 为每个维度绘制内容 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + actualBarHeight / 2; + const barWidthValue = xScale(+dataPoint[valueField1]); + + // 1. 添加国家/地区名称 - 右对齐 + // 标签位置在最左侧，右对齐 + const labelX = -flagWidth - flagMargin - textIconGap; + + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 2. 添加国家/地区图标 - 修改：使用动态大小的图标 + if (images.field && images.field[dimension]) { + // 创建一个组来包含图像 + const iconGroup = g.append("g") + .attr("transform", `translate(${-flagWidth - flagMargin}, ${centerY - flagHeight/2})`); + + // 添加国家/地区图标 + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 3. 绘制条形 - 只使用矩形 + g.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidthValue) + .attr("height", actualBarHeight) + .attr("fill", getBarColor()) + .attr("opacity", 0.9); + + // 4. 添加条形数值标签 + const formattedValue1 = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + + g.append("text") + .attr("x", barWidthValue + valueLabelGap) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue1); + + // 5. 计算圆形位置 + // 确保圆形居中放置 + const circleX = barChartWidth + maxValueWidth + valueLabelGap + circleChartWidth / 2; + const circleRadius = radiusScale(+dataPoint[valueField2]); + + // 绘制圆形 + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", getCircleColor()) + .attr("opacity", 0.7); + + // 6. 添加圆形数值标签 + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + } catch (error) { + console.error(`Error rendering chart element for ${dimension}:`, error); + } + }); + + const roughness = 1; + const bowing = 2; + const fillStyle = "solid"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_16.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_16.js new file mode 100644 index 0000000000000000000000000000000000000000..c38fcf009f92097b94c65593a556b63290a4ef36 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_16.js @@ -0,0 +1,630 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_16", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[5, 20], [0, "inf"], [2, 6]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "hierarchy":["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名称 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算图标尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度 ---------- + + // 设置边距 + const margin = { + top: 90, + right: 60, + bottom: 60, + left: 80 + }; + const innerHeight = height - margin.top - margin.bottom; + + // 计算条形的额外间距 + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // 创建初始 yScale 来计算 barHeight + const yScaleTemp = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScaleTemp.bandwidth(); + const barGap = Math.max(0, yScaleTemp.step() - yScaleTemp.bandwidth()); + const maxDimLabelHeight = barHeight + barGap; + + // 定义圆形间距 + let circleRadius = barHeight / 2; + const circlePadding = 10; + + // 使用 buildDimLabelLayout 计算维度标签布局 + const dimLabelMaxWidth = width * 0.3; + const dimLabelLineSpacing = 1.2; + + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: maxDimLabelHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: Math.min(30, barHeight * 0.6) + }); + + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + const maxLabelWidth = dimLabelLayout.maxLabelWidth; + + // 创建临时SVG来测量数值标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: Math.min(30, Math.max(12, barHeight * 0.6)), + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整左右边距 + const totalLabelWidth = (circleRadius * 2) + circlePadding + maxLabelWidth; + margin.left = Math.max(margin.left, totalLabelWidth + 20); + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 为每个组添加不同的渐变（如果启用） + if (variables.has_gradient) { + // 获取所有唯一的组值 + const uniqueGroups = [...new Set(chartData.map(d => d[groupField]))]; + + uniqueGroups.forEach(group => { + const groupColor = colorResolver.field(group, 0, { fallbackKey: "primary" }).value || "#882e2e"; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group.replace(/\s+/g, '-')}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 - 基于组值而不是索引 + const getBarColor = (dataPoint) => { + // 如果定义了字段颜色，使用它们 + if (colorResolver.field(dataPoint[groupField], 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(dataPoint[groupField], 0, { fallbackKey: "primary" }).value; + } + + // 否则使用主要颜色 + return colorResolver.other("primary", { fallback: "#882e2e" }).value; + }; + + // 获取渐变ID的辅助函数 + const getGradientId = (dataPoint) => { + return `url(#bar-gradient-${dataPoint[groupField].replace(/\s+/g, '-')})`; + }; + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const yPos = yScaleTemp(dimension); + const centerY = yPos + barHeight / 2; + const barWidth = xScale(+dataPoint[valueField]); + + // 计算圆形序号位置 + const circleX = -circleRadius * 2 - circlePadding; + const circleY = centerY; + + // 绘制条形，从圆心开始 + g.append("rect") + .attr("x", circleX) + .attr("y", yPos) + .attr("width", barWidth + Math.abs(circleX)) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? getGradientId(dataPoint) : getBarColor(dataPoint)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 绘制黑色圆形 + g.append("circle") + .attr("cx", circleX) + .attr("cy", circleY) + .attr("r", circleRadius) + .attr("fill", "#000000"); + + // 添加白色序号 + g.append("text") + .attr("x", circleX) + .attr("y", circleY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${barHeight * 0.5}px`) + .style("font-weight", "bold") + .style("fill", "#FFFFFF") + .text(index + 1); + + // 添加维度标签（支持多行换行） + const labelConfig = dimLabelConfig[dimension]; + const labelX = circleX - circleRadius - 5; + const labelGroup = g.append("text") + .attr("x", labelX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueColor = variables.has_gradient ? + getBarColor(dataPoint) : + getBarColor(dataPoint); + + g.append("text") + .attr("x", circleX + barWidth + Math.abs(circleX) + 5) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(30, Math.max(12, barHeight * 0.6))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueColor) + .text(formattedValue); + } + }); + + // ---------- 10. 改进图例 ---------- + const uniqueGroups = [...new Set(chartData.map(d => d[groupField]))]; + if (uniqueGroups.length > 1) { + // 创建新的临时SVG用于测量图例文本宽度 + const legendTempSvg = svg.append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算每个图例项的宽度 + const legendItemPadding = 10; + const legendItemHeight = 20; // 图例项高度 + const legendItemMargin = 10; // 图例项之间的间距 + + // 计算图例可用的最大宽度（60%的图表宽度） + const maxLegendWidth = width * 0.6; + + // 存储每个图例项的宽度和文本 + const legendItems = []; + + uniqueGroups.forEach(group => { + const textWidth = chartUtils.text.measure(legendTempSvg, group, { + fontFamily: typography.annotation.font_family, + fontSize: Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size))), + fontWeight: typography.annotation.font_weight + }).width; + + // 计算整个图例项的宽度 (文本宽度 + 内边距 + 矩形宽度) + const itemWidth = textWidth + legendItemPadding * 2; + + legendItems.push({ + group: group, + width: itemWidth, + textWidth: textWidth + }); + }); + + // 删除临时SVG + legendTempSvg.remove(); + chartUtils.legend.inlineTags(svg, legendItems.map(item => ({ label: item.label, color: item.color })), {}, { + x: margin.left, + y: actualLegendGroupTranslateY, + maxWidth: maxLegendWidth, + itemHeight: legendItemHeight, + itemGap: legendItemMargin, + rowGap: 5, + itemPadding: legendItemPadding, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_17.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_17.js new file mode 100644 index 0000000000000000000000000000000000000000..5d8ab35c716dcb9d2560bd3d00c147a8ee4a3ab3 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_17.js @@ -0,0 +1,617 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_17", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "hierarchy":["group"], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 0 // 左侧初始空间，后续会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名称 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值从小到大排序数据 + const sortedData = [...chartData].sort((a, b) => +a[valueField] - +b[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度和图标尺寸 ---------- + + const textPadding = 10; + const maxIconSize = 30; + const barPadding = 0.2; + const dimLabelMaxWidth = width * 0.2; + const dimLabelLineSpacing = 1.01; + + const innerHeight = height - margin.top - margin.bottom; + const yScaleTemp = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScaleTemp.bandwidth(); + const barGap = Math.max(0, yScaleTemp.step() - yScaleTemp.bandwidth()); + const maxDimLabelHeight = barHeight + barGap; + + const iconSize = calcIconSize(barHeight, { maxSize: maxIconSize, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: maxDimLabelHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: Math.min(20, barHeight * 0.6) + }); + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + const maxDimLabelWidth = dimLabelLayout.maxLabelWidth; + + const requiredLeftSpace = maxDimLabelWidth + textPadding + flagWidth + textPadding; + margin.left = requiredLeftSpace + 5; + + const innerWidth = width - margin.left - margin.right; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 获取所有唯一的组值 + const uniqueGroups = [...new Set(chartData.map(d => d[groupField]))]; + + // 为每个组添加不同的渐变（如果启用） + if (variables.has_gradient) { + uniqueGroups.forEach(group => { + const groupColor = colorResolver.field(group, 0, { fallbackKey: "primary" }).value || "#4682B4"; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group.replace(/\s+/g, '-')}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // Y轴比例尺（用于维度） + const yScale = yScaleTemp; + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = (dataPoint) => { + // 如果定义了字段颜色，使用它们 + if (colorResolver.field(dataPoint[groupField], 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(dataPoint[groupField], 0, { fallbackKey: "primary" }).value; + } + + // 否则使用主要颜色 + return colorResolver.other("primary", { fallback: "#4682B4" }).value; + }; + + // 获取渐变ID的辅助函数 + const getGradientId = (dataPoint) => { + return `url(#bar-gradient-${dataPoint[groupField].replace(/\s+/g, '-')})`; + }; + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+dataPoint[valueField])); + + const labelX = -(flagWidth + textPadding + 5); + const iconX = -flagWidth - 5; + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidthValue) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? getGradientId(dataPoint) : getBarColor(dataPoint)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 添加维度标签（支持多行换行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", labelX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 添加图标 + const groupIconUrl = jsonData.images && jsonData.images.field && jsonData.images.field[dataPoint[groupField]] ? + jsonData.images.field[dataPoint[groupField]] : + null; + + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); + + if (groupIconUrl) { + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", groupIconUrl); + } else { + iconGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("fill", getBarColor(dataPoint)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0); + } + + // 添加条形数值标签 + const valueLabel = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const textSize = Math.min(20, Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size))); + const internalPadding = 10; + const externalPadding = 5; + + let valueLabelXPos, valueLabelAnchor, valueLabelFill; + + const currentValueLabelWidth = chartUtils.text.measure(svg, valueLabel, { + fontFamily: typography.annotation.font_family, + fontSize: textSize, + fontWeight: typography.annotation.font_weight + }).width; + + if (barWidthValue >= currentValueLabelWidth + internalPadding * 2) { + valueLabelXPos = internalPadding; + valueLabelAnchor = "start"; + valueLabelFill = "#FFFFFF"; + } else { + valueLabelXPos = barWidthValue + externalPadding; + valueLabelAnchor = "start"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + } + + g.append("text") + .attr("x", valueLabelXPos) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${textSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(valueLabel); + } + }); + + // ---------- 10. 添加图例 ---------- + + // 计算图例位置和大小 + const legendRectSize = 16; + const legendSpacing = 8; + const legendTextSize = parseFloat(typography.annotation.font_size) || 12; + const legendPadding = 20; + + // 计算每组图例的宽度（使用临时元素来计算文本宽度） + const tempSvgLegend = svg.append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let legendItemWidths = []; + let totalLegendWidth = 0; + + uniqueGroups.forEach(group => { + const groupLabel = groupUnit ? + `${group}${groupUnit}` : + `${group}`; + + const textWidth = chartUtils.text.measure(tempSvgLegend, groupLabel, { + fontFamily: typography.annotation.font_family, + fontSize: legendTextSize, + fontWeight: typography.annotation.font_weight + }).width; + const itemWidth = legendRectSize + legendSpacing + textWidth + legendPadding; + + legendItemWidths.push(itemWidth); + totalLegendWidth += itemWidth; + }); + + tempSvgLegend.remove(); + const legendItems = uniqueGroups.map(group => ({ + value: group, + label: groupUnit ? `${group}${groupUnit}` : `${group}`, + color: variables.has_gradient ? `url(#bar-gradient-${String(group).replace(/\s+/g, '-') })` : (colorResolver.field(group, 0, { fallbackKey: "primary" }).value || "#4682B4"), + })); + chartUtils.legend.centered(svg, legendItems, {}, width / 2, height - margin.bottom / 2, { + markerShape: "rect", + markerSize: legendRectSize, + labelGap: legendSpacing, + itemGap: legendPadding, + fontSize: legendTextSize, + fontFamily: typography.annotation.font_family, + fontWeight: typography.annotation.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_18.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_18.js new file mode 100644 index 0000000000000000000000000000000000000000..8014acca9903c4f12267de31cf9c7dd4bdc3231b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_18.js @@ -0,0 +1,356 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_18", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js (样式02): horizontal_bar_chart_10 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#0099ff" } // 默认使用蓝色作为条形颜色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 获取图标数据 + const images = jsonData.images || {}; + + // 设置视觉效果变量 - 根据需求，删除留白、阴影和圆角等效果 + variables.has_rounded_corners = false; + variables.has_shadow = false; + variables.has_gradient = true; // 强制开启渐变 + variables.has_stroke = false; + variables.has_spacing = false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const originalHeight = variables.height || 600; + + // 设置边距 - 这个样式需要更多的上部和下部空间用于标签 + const margin = { + top: 90, // 顶部边距 + right: 40, // 右侧足够显示数值标签 + bottom: 60, // 底部边距 + left: 30 // 左侧边距 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据（与图片相符） + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 5. 计算标签宽度、动态高度和图表尺寸 ---------- + + // 动态调整高度 + const numDimensions = sortedDimensions.length; + let adjustedHeight = originalHeight; + const maxHeightFactor = 1.88; + + if (numDimensions > 18) { + // 根据条目数量比例计算建议高度 + const suggestedHeight = originalHeight * (numDimensions / 18); + // 限制最大高度 + adjustedHeight = Math.min(suggestedHeight, originalHeight * maxHeightFactor); + } + + // 使用调整后的高度 + const height = adjustedHeight; + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整右边距 + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用调整后的高度 + .attr("viewBox", `0 0 ${width} ${height}`) // 使用调整后的高度 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（取消留白） + const barPadding = 0.55; // 设置适当的间距以确保有足够空间放置标签和图标 + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // 确保小值仍然可见 - 设置最小宽度为0，确保严格按比例绘制 + const getBarWidth = (value) => { + return xScale(value); + }; + + // ---------- 8. 自适应图标和字体大小计算 ---------- + + // 计算条形之间的距离和条形高度 + const barStep = yScale.step(); + const barHeight = yScale.bandwidth(); + + // 计算标签和图标可用的空间（条形上方的空间） + const availableLabelSpace = barStep - barHeight; + + // 设置标签和图标的最大高度，确保不会重叠 + // 允许标签和图标总高度最多占可用空间的90% + const maxTotalHeight = availableLabelSpace * 0.9; + + // 为标签和图标分配空间 + // 图标大小设为总高度的65%，文本设为35% + const iconHeight = Math.min(barHeight * 0.8, maxTotalHeight * 0.65); + const iconWidth = iconHeight; // 保持图标宽高比 + + // 基于图标的高度计算合适的字体大小，因为它们是并排的 + // 字体大小通常是所需高度的约80% + const targetFontSizeBasedOnIcon = iconHeight * 0.9; + const fontSize = Math.max(4, Math.min(16, targetFontSizeBasedOnIcon)); // 限制字体大小在8px到12px之间 + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 为每个维度创建独立的渐变 ---------- + sortedDimensions.forEach((dimension, i) => { + // 获取条形颜色 - 从colors.field中获取，如果不存在则使用默认主色 + let barColor = colorResolver.other("primary").value; + barColor = colorResolver.field(dimension, 0, { fallback: barColor }).value; + + // 为每个条形创建专用渐变 + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); // 左侧暗色 + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 0.8 })); // 右侧亮色 + }); + + // ---------- 11. 绘制条形和标签 ---------- + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, i) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barWidth = getBarWidth(+dataPoint[valueField]); + const yPosition = yScale(dimension); + + // ---------- 创建条形组 ---------- + const barGroup = g.append("g") + .attr("transform", `translate(0, ${yPosition})`); + + // ---------- 添加图标和维度标签（在条形上方）---------- + // 创建一个用于图标和标签的容器组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${yPosition - 2})`); // 紧贴条形上方的位置 + + // 标签水平位置 - 根据是否有图标调整 + let labelX = 0; // 默认从左侧开始 + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + labelGroup.append("image") + .attr("x", 0) // 与条形左侧对齐 + .attr("y", -iconHeight) // 图标放在条形上方 + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + + // 如果有图标，调整标签位置 + labelX = iconWidth + 5; + } + + // 添加维度标签 + labelGroup.append("text") + .attr("x", labelX) + .attr("y", -iconHeight / 2) // 垂直位置与图标中心对齐 + .attr("dy", "0.35em") // 垂直微调以居中 + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize}px`) // 使用新的fontSize + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // ---------- 绘制条形 ---------- + // 获取条形颜色 + let barColor = colorResolver.other("primary").value; + barColor = colorResolver.field(dimension, 0, { fallback: barColor }).value; + + // 绘制条形 - 右侧带有圆角 + barGroup.append("path") + .attr("d", function() { + const radius = barHeight / 2; + + // 处理零或负值，避免绘制错误 + if (barWidth <= 0) { + return ""; // 不绘制任何路径 + } + + // 当条形宽度小于半径时，绘制一个椭圆弧段，确保最右点为 barWidth + if (barWidth < radius) { + // M 移动到起点 (0, 0) + // A 绘制椭圆弧: rx=barWidth, ry=radius, 旋转=0, 小弧=0, 顺时针=1, 终点=(0, barHeight) + // Z 关闭路径 + return `M 0,0 A ${barWidth},${radius} 0 0,1 0,${barHeight} Z`; + } + // 当条形宽度大于等于半径时，绘制矩形 + 半圆 + else { + // M 移动到起点 (0, 0) + // H 水平线到半圆开始处 (barWidth - radius, 0) + // A 绘制标准圆弧: rx=radius, ry=radius, 旋转=0, 小弧=0, 顺时针=1, 终点=(barWidth - radius, barHeight) + // H 水平线回到左侧 (0, barHeight) + // Z 关闭路径 + return `M 0,0 H ${barWidth - radius} A ${radius},${radius} 0 0,1 ${barWidth - radius},${barHeight} H 0 Z`; + } + }) + .attr("fill", `url(#bar-gradient-${i})`) // 使用每个条的独立渐变 + .style("stroke", "none"); + + // 添加数值标签（在条形右侧） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + barGroup.append("text") + .attr("x", barWidth + 5) // 条形右侧5px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_19.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_19.js new file mode 100644 index 0000000000000000000000000000000000000000..4726e42a27275764d593488db6a4b64b635c9747 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_19.js @@ -0,0 +1,326 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_19", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 右对齐水平条形图实现 - 使用D3.js (集成图标和独立颜色) horizontal_bar_chart_11 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#E74C3C" } // 默认使用红色作为条形颜色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const images = jsonData.images || {}; // 获取图标数据 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 - 增加顶部边距以容纳Y轴名称和第一个标签/图标 + const margin = { + top: 100, // 增加顶部边距 + right: 10, // 最小右侧边距 + bottom: 60, // 底部边距 + left: 10 // 左侧边距，留足空间放置数值标签 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值从小到大排序数据 + const orderedData = [...chartData].sort((a, b) => +a[valueField] - +b[valueField]); + const orderedDimensions = orderedData.map(d => d[dimensionField]); + + // 计算最小和最大值用于比例尺 + const minValue = d3.min(chartData, d => +d[valueField]); + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 确定是否有负值 + const hasNegativeValues = minValue < 0; + + // 添加数值格式化函数 + + // ---------- 5. 计算标签宽度和图表尺寸 ---------- + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大维度标签宽度（用于潜在的布局调整，这里暂时不用） + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + const formattedDimension = dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}`; + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据数值标签宽度调整左边距 + margin.left = Math.max(margin.left, maxValueWidth + 10); // 增加一点间距 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = 0.55; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(orderedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值）- 右对齐 + const xScale = d3.scaleLinear() + .domain([ + hasNegativeValues ? Math.min(minValue * 1.1, 0) : 0, + Math.max(maxValue * 1.1, 0) + ]) + .range([0, innerWidth]); + + // ---------- 8. 动态图标和标签大小计算 (恢复基于可用空间) ---------- + const barStep = yScale.step(); + const barHeight = yScale.bandwidth(); + // 计算条形本身之间的垂直间隙 + const gapBetweenBars = barStep - barHeight; + + // 允许图标/标签使用的最大垂直空间（例如，间隙的80%） + const maxTotalHeight = Math.max(15, gapBetweenBars * 0.8); // 保证最小15px + + // 根据最大总高度分配图标和标签的高度 + // 图标高度占总高度的约 70%，但不超过 barHeight 的 90%，且不超过20px + const iconHeight = Math.min(barHeight * 0.9, maxTotalHeight * 0.7, 20); + const iconWidth = iconHeight; // 保持图标宽高比 + + // 基于图标高度计算维度标签的字体大小 (因为并排) + const targetLabelFontSize = iconHeight * 0.9; + const labelFontSize = `${Math.max(4, Math.min(16, targetLabelFontSize))}px`; // 限制范围 8px-16px, 并转为字符串 + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 添加Y轴名称 (Value Field Name) ---------- + const yAxisName = valueField; // Y轴使用的字段名 + g.append("text") + .attr("x", innerWidth) // 右对齐到绘图区边缘 + .attr("y", -5) + .attr("dy", "0.35em") // 垂直微调 + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) // 使用label的字体设置 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 默认文本颜色 + .text(yAxisName); + + // ---------- 11. 绘制条形、标签和图标 ---------- + + orderedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const yPosition = yScale(dimension); + const value = +dataPoint[valueField]; + + // 获取特定颜色和图标 + const barColor = colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value; + const iconSrc = (images.field && images.field[dimension]) ? images.field[dimension] : null; + + // 为每个bar创建独立的渐变 + const gradientId = `bar-gradient-${index}`; + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + // 定义从左到右的渐变，中间最亮，两边较暗 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 2.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); + + // 计算条形宽度和位置 - 右对齐 + let barWidth = Math.abs(xScale(value) - xScale(0)); + let barX = value >= 0 ? innerWidth - barWidth : innerWidth - barWidth; // 考虑负值（虽然此图表类型通常不处理） + + // ---------- 添加图标和维度标签（条形上方，右对齐 - 使用动态计算）---------- + let labelEndX = innerWidth; // 标签默认结束于右边缘 + + // 添加图标（如果存在） + if (iconSrc) { + g.append("image") // 直接添加到主绘图组g + .attr("x", innerWidth - iconWidth) // 使用动态iconWidth + .attr("y", yPosition - iconHeight - 5) // 使用动态iconHeight + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", iconSrc); + + // 如果有图标，标签向左移动一点 + labelEndX = innerWidth - iconWidth - 8; // 8px间距 + } + + // 添加维度标签 + const formattedDimension = dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}`; + g.append("text") // 直接添加到主绘图组g + .attr("x", labelEndX) // 结束位置（右对齐） + // 垂直居中于图标的位置 (基于动态 iconHeight) + .attr("y", yPosition - 5 - iconHeight / 2) + .attr("dy", "0.35em") // 垂直微调 + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", labelFontSize) // 使用动态计算的字号 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedDimension); + + // ---------- 创建条形组（为了方便管理标签和条形） ---------- + const barGroup = g.append("g") + .attr("transform", `translate(0, ${yPosition})`); + + // ---------- 绘制条形 (简化实现，使用rect元素实现左侧圆角) ---------- + barGroup.append("rect") + .attr("x", barX) + .attr("y", 0) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", `url(#${gradientId})`) // 使用每个bar独立的渐变 + .attr("rx", barHeight / 4) // 左侧圆角 + .attr("ry", barHeight / 4); + + // ---------- 添加数值标签（条形外侧左边） ---------- + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + barGroup.append("text") + .attr("x", barX - 5) // 条形外左侧5px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "end") // 右对齐（相对于x坐标） + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18, Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用默认文本颜色 + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2.js new file mode 100644 index 0000000000000000000000000000000000000000..b42d5f479cc715181f995c4ece49d6b6ef92b7e5 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2.js @@ -0,0 +1,216 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_2", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([0, chartWidth]) + .nice(); + + const n_data = processedData.length + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === n_data - 1) { + return colorResolver.variant(colorResolver.other("primary").value, { mode: "brighter", amount: 0.8 }); + } + return colorResolver.other("primary").value; + }; + + // 确定标签的最大长度： + let minYLabelRatio = 1.0 + const maxYLabelWidth = yScale.bandwidth() * 1.03 + + chartData.forEach(d => { + const yLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, yLabelText).width + if (currentWidth > maxYLabelWidth) { + minYLabelRatio = Math.min(minYLabelRatio, maxYLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", "end") + .attr("dy", "0.32em") + .attr("x", -10) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("y", d => yScale(d.category)) + .attr("x", 0) + .attr("width", d => xScale(d.value)) + .attr("height", yScale.bandwidth()) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.value) + 5) + .attr("y", d => yScale(d.category) + yScale.bandwidth() / 2) + .attr("dy", "0.32em") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_20.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_20.js new file mode 100644 index 0000000000000000000000000000000000000000..75b70c344bdcafe063ba7e5b9e8459d80940175b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_20.js @@ -0,0 +1,405 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_20", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["x"], + "supported_effects": ["radius_corner", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "none", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js horizontal_bar_chart_composite_02 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 - 初始值，稍后会根据标签长度调整 + const margin = { + top: 90, // 顶部留出标题空间 + right: 40, // 右侧足够显示数值 + bottom: 40, // 底部边距 + left: 40 // 左侧空间，稍后会调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "total"; + + // 获取字段单位 + let valueUnit = ""; + let valueUnit2 = ""; + valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + // 添加维度单位定义 + const dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "x").unit; + + // 获取y2字段的显示名称用于标题 + const valueField2Name = chartUtils.schema.channel(jsonData, "y2").raw?.display_name || valueField2; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 5. 计算标签宽度 ---------- + + // 序号宽度 + const rankingWidth = 25; + + // 图标尺寸 + let flagWidth = 40; + let flagHeight = 40; + const flagPadding = 5; // 图标与标签之间的间距 + const labelMeasureOptions = { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }; + const annotationMeasureOptions = { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }; + + // 计算最大维度标签宽度（不包括图标和序号） + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, labelMeasureOptions).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(null, formattedValue, annotationMeasureOptions).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 计算最大第二数值标签宽度 + let maxValueWidth2 = 0; + chartData.forEach(d => { + const formattedValue2 = valueUnit2 ? + `${chartUtils.format.autoText(+d[valueField2])}${valueUnit2}` : + `${chartUtils.format.autoText(+d[valueField2])}`; + + const textWidth = chartUtils.text.measure(null, formattedValue2, annotationMeasureOptions).width; + + maxValueWidth2 = Math.max(maxValueWidth2, textWidth); + }); + + // 计算y2字段标题的宽度 + const y2TitleWidth = chartUtils.text.measure(null, valueField2Name, labelMeasureOptions).width; + + // 使用最大的第二值宽度和标题宽度 + maxValueWidth2 = Math.max(maxValueWidth2, y2TitleWidth); + + // 计算左边距，考虑 标签 + 图标之间的间距 + // 序号在最左边，然后是标签（右对齐），然后是图标 + const totalLeftPadding = maxLabelWidth + flagWidth + flagPadding; + margin.left = Math.max(margin.left, totalLeftPadding); + + // 设置右边距，考虑第二个数值标签 + 固定距离 20px + margin.right = Math.max(margin.right, maxValueWidth2 + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) // 使用固定宽度而不是百分比 + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + // 如果有背景颜色设置，添加背景 + if (colorResolver.background({ fallback: "#FFFFFF" }).value) { + svg.style("background-color","#8BC34A" ); + } + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#1d6b64" }).value; + + // 添加水平渐变（从左到右） + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + // ---------- 7. 创建比例尺 ---------- + + // 设置固定的条形间距 + const barPadding = 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取描边颜色的辅助函数 + const getStrokeColor = (dimension) => { + // 获取条形的基础颜色 + const baseColor = getBarColor(dimension); + // 返回该颜色的更亮版本 + return colorResolver.variant(baseColor, { mode: "brighter", amount: 3 }); + }; + + // 获取条形颜色的辅助函数 + const getBarColor = (dimension) => { + // 获取维度对应的颜色 + return colorResolver.field(dimension, 0, { fallback: primaryColor }).value; + }; + + // 计算图标区域的尺寸和位置 + const barHeight = yScale.bandwidth(); + const iconWidth = barHeight * 1.1; // 与下方图标尺寸保持一致 + const iconX = -iconWidth - flagPadding; + const iconContainerWidth = iconWidth + 2*flagPadding; // 图标宽度加上一些额外的空间，用于覆盖条形图的一部分 + const iconContainerHeight = innerHeight; + + // 添加y2字段标题（在第一行上方） + g.append("text") + .attr("x", innerWidth + margin.right - 10) // 右对齐，距离图表右边缘10px + .attr("y", - 5) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(valueField2Name); + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", "url(#bar-gradient)") // 强制使用渐变填充 + .attr("rx", 4) // 强制使用圆角半径4 + .attr("ry", 4) // 强制使用圆角半径4 + .style("stroke", getStrokeColor(dimension)) // 强制应用描边 + .style("stroke-width", 1) // 强制设置描边宽度为1 + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 设置图标尺寸与条形高度一致 + const adjustedFlagWidth = barHeight*1.1; // 图标宽度与条形高度相同 + const adjustedFlagHeight = barHeight*1.1; // 图标高度与条形高度相同 + + // 计算每个标签的位置 + // 图标位置：紧贴条形左边 + const iconX = -adjustedFlagWidth - flagPadding; + + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + // 标签位置：在图标左侧，右对齐（相对于最长标签） + const labelX = iconX - flagPadding; + + // 添加维度图标 + if (images.field && images.field[dimension]) { + // 设置图标尺寸为条形高度的90% + const iconHeight = barHeight * 0.9; + const iconWidth = iconHeight; // 保持正方形 + const centerY = yScale(dimension) + barHeight / 2; + const clipPathId = `clip-${dimension.replace(/\W/g, '')}-${index}`; + + // 创建裁剪路径 + defs.append("clipPath") + .attr("id", clipPathId) + .append("circle") + .attr("cx", iconX + iconWidth/2) + .attr("cy", centerY) + .attr("r", iconWidth * 0.5); + + // 绘制细边框圆圈 + g.append("circle") + .attr("cx", iconX + iconWidth/2) + .attr("cy", centerY) + .attr("r", iconWidth * 0.5) + .attr("fill", "none") + .attr("stroke", "#000") + .attr("stroke-width", 0.5); + + // 添加裁剪后的图像 + g.append("image") + .attr("x", iconX) + .attr("y", centerY - iconHeight/2) + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("clip-path", `url(#${clipPathId})`) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签 + g.append("text") + .attr("x", labelX) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.max(barHeight * 0.5, 8)}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedDimension); + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${Math.max(barHeight * 0.5, 8)}px`; + // 格式化数值 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueTextWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: dynamicFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断是否能在条形内部放置文本（需要多留一些边距） + const textFitsInside = barWidth > valueTextWidth + 5; + + // 添加数值标签（在条形内部或外部） + g.append("text") + .attr("x", textFitsInside ? barWidth / 2 : barWidth + 5) // 内部居中，外部在右侧 + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", textFitsInside ? "middle" : "start") // 内部居中对齐，外部左对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", textFitsInside ? "#ffffff" : colorResolver.text({ fallback: "#333333" }).value) // 在内部时使用白色，在外部时使用文本颜色 + .text(formattedValue); + + // 格式化第二数值 + const formattedValue2 = valueUnit2 ? + `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}` : + `${chartUtils.format.autoText(+dataPoint[valueField2])}`; + + // 添加第二数值标签（在右边缘，右对齐，距离右边缘20px） + g.append("text") + .attr("x", innerWidth + margin.right - 20) // 右对齐，距离图表右边缘20px + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_21.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_21.js new file mode 100644 index 0000000000000000000000000000000000000000..2c619dc14093b7781b3347bc90f2f3d25924396d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_21.js @@ -0,0 +1,615 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_21", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 20], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["radius_corner", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "none", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js horizontal_bar_chart_composite_03 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 - 初始值，稍后会根据标签长度调整 + const margin = { + top: 90, // 顶部留出标题空间 + right: 40, // 右侧足够显示数值 + bottom: 40, // 底部边距 + left: 40 // 左侧空间，稍后会调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "total"; + + // 获取字段单位 + let valueUnit = ""; + let valueUnit2 = ""; + valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + // 添加维度单位定义 + const dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "x").unit; + + // 获取y2字段的显示名称用于标题 + const valueField2Name = chartUtils.schema.channel(jsonData, "y2").raw?.display_name || valueField2; + // 获取y1字段的显示名称用于标题 + const valueFieldName = chartUtils.schema.channel(jsonData, "y").raw?.display_name || valueField; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算图标尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度 ---------- + + // 图标尺寸 + const flagPadding = 5; // 图标与标签之间的间距 + + // 使用智能换行计算标签布局 + const estimatedBarHeight = (height - margin.top - margin.bottom) / sortedDimensions.length / (1 + 0.2); + const targetFontSize = Math.max(estimatedBarHeight * 0.4, 8); + const maxLabelWidthAvailable = 200; // 标签最大可用宽度 + const labelLineSpacing = 1.2; + + const labelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: { + font_family: typography.label.font_family, + font_weight: typography.label.font_weight + }, + maxWidth: maxLabelWidthAvailable, + maxHeight: estimatedBarHeight, + lineSpacing: labelLineSpacing, + targetFontSize: targetFontSize + }); + + const dimLabelConfig = labelLayout.dimLabelConfig; + const maxLabelWidth = labelLayout.maxLabelWidth; + + // 计算最大数值标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 计算最大第二数值标签宽度 + let maxValueWidth2 = 0; + chartData.forEach(d => { + const formattedValue2 = valueUnit2 ? + `${chartUtils.format.autoText(+d[valueField2])}${valueUnit2}` : + `${chartUtils.format.autoText(+d[valueField2])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue2, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth2 = Math.max(maxValueWidth2, textWidth); + }); + + // 计算y2字段标题的宽度 + const y2TitleWidth = chartUtils.text.measure(tempSvg, valueField2Name, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + // 使用最大的第二值宽度和标题宽度 + maxValueWidth2 = Math.max(maxValueWidth2, y2TitleWidth); + + // 删除临时SVG + tempSvg.remove(); + + // 计算左边距，仅考虑标签宽度和一些间距 + margin.left = Math.max(margin.left, maxLabelWidth + flagPadding * 2); + + // 设置右边距，考虑第二个数值标签 + 固定距离 20px + margin.right = Math.max(margin.right, maxValueWidth2 + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) // 使用固定宽度而不是百分比 + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + // 如果有背景颜色设置，添加背景 + if (colorResolver.background({ fallback: "#FFFFFF" }).value) { + svg.style("background-color","#8BC34A" ); + } + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#1d6b64" }).value; + const secondaryColor = colorResolver.other("secondary", { fallback: "#ff7f0e" }).value; // 获取次要颜色，设置默认值 + + // ---------- 7. 创建比例尺 ---------- + + // 设置固定的条形间距 + const barPadding = 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // 为右侧正方形创建面积比例尺 + const barH = yScale.bandwidth(); // 获取单个bar的高度 + const maxY2 = d3.max(chartData, d => +d[valueField2]); + const minSideLength = 10; // 最小边长 + const maxSideLength = barH * 2; // 最大边长 + const squareSideScale = d3.scaleSqrt() // 使用sqrt比例尺映射面积到边长 + .domain([0, maxY2]) // Y2值范围 + .range([minSideLength, maxSideLength]) // 映射到边长范围 + .clamp(true); // 防止超出范围 + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = (dimension) => { + // 获取维度对应的颜色 + return colorResolver.field(dimension, 0, { fallback: primaryColor }).value; + }; + + // 计算图标区域的尺寸和位置 + const barHeight = yScale.bandwidth(); + const iconWidth = barHeight * 1.1; // 与下方图标尺寸保持一致 + const iconX = -iconWidth - flagPadding; + const iconContainerWidth = iconWidth + 2*flagPadding; // 图标宽度加上一些额外的空间，用于覆盖条形图的一部分 + const iconContainerHeight = innerHeight; + + // 添加y1字段标题（在第一行上方，左对齐） + g.append("text") + .attr("x", 0) // 左对齐到条形图起点 + .attr("y", -10) // 与y2标题垂直对齐 + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(valueFieldName); + + // 添加y2字段标题（在第一行上方） + g.append("text") + .attr("x", innerWidth + margin.right - 10) // 右对齐，距离图表右边缘10px + .attr("y", - 10) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(valueField2Name); + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", primaryColor) // 强制使用主颜色填充 + .attr("rx", barHeight / 2) // 强制使用圆角半径 barHeight / 2 + .attr("ry", barHeight / 2) // 强制使用圆角半径 barHeight / 2 + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 标签位置：条形左侧，右对齐 + const labelX = -flagPadding; + const centerY = yScale(dimension) + barHeight / 2; + + // 添加维度标签（支持智能换行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", labelX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + // 多行换行 + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + // 单行 + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${Math.max(barHeight * 0.4, 8)}px`; + // 格式化数值 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: dynamicFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // -- 计算 Y2 和正方形属性 -- （移到此处） + const y2Value = +dataPoint[valueField2]; + const sideLength = squareSideScale(y2Value); + const squareX = innerWidth + margin.right / 2 - sideLength / 2; // 水平居中于右侧边距 + const squareY = yScale(dimension) + barHeight / 2 - sideLength / 2; // 垂直居中于条形 + const formattedValue2 = valueUnit2 ? `${chartUtils.format.autoText(y2Value)}${valueUnit2}` : `${chartUtils.format.autoText(y2Value)}`; + + // -- 添加 Y 数值标签 (考虑重叠) -- + const textFitsInside = barWidth > valueTextWidth + 10; // 内部判断加宽边距 + const outsideX = barWidth + 5; + const wouldOverlap = !textFitsInside && (outsideX + valueTextWidth > squareX); + + let labelXPos, labelAnchor, labelFill; + if (textFitsInside) { + labelXPos = barWidth / 2; + labelAnchor = "middle"; + labelFill = "#ffffff"; + } else if (wouldOverlap) { + labelXPos = barWidth / 2; // 强制放内部 + labelAnchor = "middle"; + labelFill = "#ffffff"; // 内部用白色 + } else { + labelXPos = outsideX; // 放外部 + labelAnchor = "start"; + labelFill = colorResolver.text({ fallback: "#333333" }).value; + } + + g.append("text") + .attr("x", labelXPos) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", labelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelFill) + .text(formattedValue); + + // -- 绘制右侧正方形 -- + g.append("rect") + .attr("x", squareX) + .attr("y", squareY) + .attr("width", sideLength) + .attr("height", sideLength) + .attr("fill", secondaryColor) + .attr("opacity", 0.6); + + // -- 添加 Y2 数值标签 (居中于正方形) -- + g.append("text") + .attr("x", squareX + sideLength / 2) // 水平居中 + .attr("y", squareY + sideLength / 2) // 垂直居中 + .attr("dy", "0.35em") + .attr("text-anchor", "middle") // 居中对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) // Use same dynamic font size + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_22.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_22.js new file mode 100644 index 0000000000000000000000000000000000000000..49cb9ae6b5b7c50599e0b41a9b323bf5a86053fd --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_22.js @@ -0,0 +1,522 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_22", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例方形复合图表实现 - 使用D3.jshorizontal_bar_chart_composite_04 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 5, // 右侧边距 + bottom: 40, // 底部边距 + left: 10 // 左侧边距，给文字留出一些空间 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y", { fallbackKey: "Crypto Ownership Percentage" }).key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题（使用数据列的name字段，而不是description） + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // ---------- 4. 数据处理 ---------- + + // 按第一个数值字段降序排序数据 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 5. 布局计算 ---------- + const flagWidth = 30; // 图标宽度 + const flagHeight = 30; // 图标高度 + const textPadding = 5; // 文本与图标/边缘的间距 + const labelGap = 10; // 外部标签间距 + + // 更新左边距 (仅考虑图标和padding) + const requiredLeftSpace = flagWidth + textPadding; + margin.left = requiredLeftSpace + 5; // 加5px额外缓冲 + + // 设置条形图和方形图的布局比例 + const leftColumnRatio = 0.85; // 左列占比 + const rightColumnRatio = 0.15; // 右列占比 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算两列的宽度 + const barChartWidth = innerWidth * leftColumnRatio; + const circleChartWidth = innerWidth * rightColumnRatio; + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于第一个数值）- 条形图 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barChartWidth]); + + // 正方形面积比例尺（用于第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minSideLength = yScale.bandwidth() * 0.1; // 最小边长为bar height的10% + const maxSideLength = Math.min(yScale.bandwidth() * 1.0, circleChartWidth * 0.8); // 最大边长 + + const squareSideScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minSideLength, maxSideLength]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 8. 添加SVG定义 ---------- + + // ---------- 9. 添加标题和标题下的线条 ---------- + + // 计算标题位置 + const titleY = margin.top - 25; + const lineY = margin.top - 10; + + // 创建一个临时的SVG元素用于文本测量 + const tempTextSvg = d3.select(containerSelector).append("svg") + .attr("width", 0) + .attr("height", 0) + .style("opacity", 0) + .style("position", "absolute"); + + // ---------- Helper: Get Wrapped Lines ---------- + function getWrappedLines(textContent, availableWidth, fontConfig, tempSvg) { + const words = (textContent || "").trim().toUpperCase().split(/\s+/).filter(w => w !== ""); // 转大写 + const lines = []; + const fontSizeValue = parseFloat(fontConfig.font_size); + const lineHeight = fontSizeValue * 1.2; + + if (words.length === 0) { + return { linesArray: [], numLines: 0, lineHeight: lineHeight }; + } + + let currentLine = words[0]; + for (let i = 1; i < words.length; i++) { + const word = words[i]; + const testLine = currentLine + " " + word; + if (estimateGenericTextWidth(testLine, fontConfig, tempSvg) > availableWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + if (currentLine !== "") { + lines.push(currentLine); + } + + return { linesArray: lines, numLines: lines.length, lineHeight: lineHeight }; + } + + // ---------- Helper: Estimate Generic Text Width ---------- + function estimateGenericTextWidth(text, fontConfig, tempSvg) { + return chartUtils.text.measure(tempSvg, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 重构标题部分 ---------- + const titleFontConfig = typography.description; + const titleBottomPadding = 10; // 标题底部与横线之间的间距 + const desiredBaselineOfLastLine = lineY - titleBottomPadding; // 横线上方10px + + // 左侧列标题 + const leftTitleAvailableWidth = barChartWidth * 0.9; // 左侧标题可用宽度，给一些padding + const leftTitleXPos = margin.left; + const wrappedLeftTitle = getWrappedLines(columnTitle1, leftTitleAvailableWidth, titleFontConfig, tempTextSvg); + + if (wrappedLeftTitle.numLines > 0) { + const initialYLeft = desiredBaselineOfLastLine - (wrappedLeftTitle.numLines - 1) * wrappedLeftTitle.lineHeight; + const leftTitleText = svg.append("text") + .attr("x", leftTitleXPos) + .attr("y", initialYLeft) + .attr("text-anchor", "start") + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedLeftTitle.linesArray.forEach((line, i) => { + leftTitleText.append("tspan") + .attr("x", leftTitleXPos) + .attr("dy", i === 0 ? 0 : wrappedLeftTitle.lineHeight) + .text(line); + }); + } + + // 右侧列标题 + const rightTitleAvailableWidth = circleChartWidth * 0.9; // 右侧标题可用宽度 + const rightTitleXPos = margin.left + barChartWidth + circleChartWidth; // 右对齐到右侧区域的末尾 + const wrappedRightTitle = getWrappedLines(columnTitle2, rightTitleAvailableWidth, titleFontConfig, tempTextSvg); + + if (wrappedRightTitle.numLines > 0) { + const initialYRight = desiredBaselineOfLastLine - (wrappedRightTitle.numLines - 1) * wrappedRightTitle.lineHeight; + const rightTitleText = svg.append("text") + .attr("x", rightTitleXPos) + .attr("y", initialYRight) + .attr("text-anchor", "end") // 右侧标题右对齐 + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedRightTitle.linesArray.forEach((line, i) => { + rightTitleText.append("tspan") + .attr("x", rightTitleXPos) + .attr("dy", i === 0 ? 0 : wrappedRightTitle.lineHeight) + .text(line); + }); + } + + // 标题下的黑线 (位置不变) + svg.append("line") + .attr("x1", margin.left) + .attr("y1", lineY) + .attr("x2", width - margin.right) + .attr("y2", lineY) + .attr("stroke", "#000000") + .attr("stroke-width", 1.5); + + // 清理临时SVG元素 + tempTextSvg.remove(); + + + // ---------- 10. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 11. 获取条形图颜色的辅助函数 ---------- + + // 获取条形图颜色 + const getBarColor = (dimension) => { + return colorResolver.field(dimension, 0, { fallback: colorResolver.other("primary", { fallback: "#83C341" }).value }).value; + }; + + // 重命名函数，逻辑不变 (获取正方形/条形颜色) + const getShapeColor = getBarColor; + + // ---------- 13. 为每个维度绘制条形和正方形 ---------- + + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = xScale(+dataPoint[valueField1]); + + // 定义图标X坐标 + const iconX = -(flagWidth + textPadding); // 图标放在最左侧，考虑padding + + // 1. 添加图标（如果有） + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); + + if (images.field && images.field[dimension]) { + iconGroup.append("image") + .attr("x", -5) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } else { + // 占位符 + iconGroup.append("rect") + .attr("width", flagWidth * 0.8) + .attr("height", flagHeight * 0.8) + .attr("x", flagWidth * 0.1) + .attr("y", flagHeight * 0.1) + .attr("fill", getShapeColor(dimension)) + .attr("opacity", 0.6); + } + + // 2. 绘制条形（右侧圆角） + const radius = barHeight / 2; + const arcStartX = Math.max(0, barWidthValue - radius); + g.append("path") + .attr("d", `M 0,${y} + L ${arcStartX},${y} + A ${radius},${radius} 0 0,1 ${barWidthValue},${centerY} + A ${radius},${radius} 0 0,1 ${arcStartX},${y + barHeight} + L 0,${y + barHeight} + Z`) + .attr("fill", getBarColor(dimension)); // 直接使用颜色填充 + + // 3. 准备标签文本和测量宽度 + const dimensionLabelText = dimension.toUpperCase(); + const formattedValue1 = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + const valueLabelFontSize = typography.label.font_size; + const dimensionLabelFontSize = typography.label.font_size; + + const countryLabelWidth = chartUtils.text.measure(g, dimensionLabelText, { + fontFamily: typography.label.font_family, + fontSize: dimensionLabelFontSize, + fontWeight: typography.label.font_weight + }).width; + + const valueTextWidth = chartUtils.text.measure(g, formattedValue1, { + fontFamily: typography.label.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 4. 决定并绘制标签 + let dimLabelX, dimLabelAnchor, dimLabelFill; + let valueLabelX, valueLabelAnchor, valueLabelFill; + + const canDimFitInside = barWidthValue >= countryLabelWidth + 2 * textPadding; // 左右各5px padding + const canValueAlsoFitInside = barWidthValue >= textPadding + countryLabelWidth + textPadding + valueTextWidth + textPadding; // 多加一个标签间padding + + if (canDimFitInside) { + // 维度标签放内部左侧 + dimLabelX = textPadding; + dimLabelAnchor = "start"; + dimLabelFill = "#FFFFFF"; + g.append("text") + .attr("x", dimLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", dimLabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", dimensionLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", dimLabelFill) + .text(dimensionLabelText); + + if (canValueAlsoFitInside) { + // 数值标签放内部右侧 + valueLabelX = barWidthValue - textPadding; + valueLabelAnchor = "end"; + valueLabelFill = "#FFFFFF"; + } else { + // 数值标签放外部右侧 + valueLabelX = barWidthValue + textPadding; + valueLabelAnchor = "start"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + } + // 绘制数值标签 + g.append("text") + .attr("x", valueLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", valueLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", valueLabelFill) + .text(formattedValue1); + + } else { + // 维度标签放外部右侧 + dimLabelX = barWidthValue + textPadding; + dimLabelAnchor = "start"; + dimLabelFill = colorResolver.text({ fallback: "#333333" }).value; + const externalDimLabel = g.append("text") // 保存引用以获取宽度 + .attr("x", dimLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", dimLabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", dimensionLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", dimLabelFill) + .text(dimensionLabelText); + + // 获取外部维度标签的实际渲染宽度 + const externalDimLabelWidth = chartUtils.text.measure(g, dimensionLabelText, { + fontFamily: typography.label.font_family, + fontSize: dimensionLabelFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 数值标签放外部维度标签右侧 + valueLabelX = dimLabelX + externalDimLabelWidth + labelGap; + valueLabelAnchor = "start"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + // 绘制数值标签 + g.append("text") + .attr("x", valueLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.label.font_family) + .style("font-size", valueLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", valueLabelFill) + .text(formattedValue1); + } + + // 5. 绘制正方形和数值标签 + const sideLength = squareSideScale(+dataPoint[valueField2]); + const squareX = barChartWidth + circleChartWidth / 2 - sideLength / 2; // 水平居中 + const squareY = y + barHeight / 2 - sideLength / 2; // 垂直居中 + const squareFill = getShapeColor(dimension); + + // 绘制正方形（无视觉效果） + g.append("rect") + .attr("x", squareX) + .attr("y", squareY) + .attr("width", sideLength) + .attr("height", sideLength) + .attr("fill", squareFill); // 直接使用颜色填充 + + // 添加正方形数值标签 + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + const squareLabelFontSize = typography.label.font_size; // 使用label字体大小 + + const value2TextWidth = chartUtils.text.measure(g, formattedValue2, { + fontFamily: typography.label.font_family, + fontSize: squareLabelFontSize, + fontWeight: typography.label.font_weight + }).width; + + // 判断文本是否能放入正方形内 + let textFitsInSquare = (sideLength > value2TextWidth + 10); // 需要10px的内边距 + + if (textFitsInSquare) { + // 文本放在正方形内，白色 + g.append("text") + .attr("x", squareX + sideLength / 2) // 居中 + .attr("y", squareY + sideLength / 2) // 居中 + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", squareLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", "#FFFFFF") + .text(formattedValue2); + } else { + // 文本放在正方形上方，与正方形颜色相同 + g.append("text") + .attr("x", squareX + sideLength / 2) // 水平居中 + .attr("y", squareY - 2) // 正方形上方一点 + .attr("dy", "0em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", squareLabelFontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", squareFill) // 与正方形同色 + .text(formattedValue2); + } + + } catch (error) { + console.error(`Error rendering chart element for ${dimension}:`, error); + // Continue with the next item instead of stopping the entire chart + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_23.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_23.js new file mode 100644 index 0000000000000000000000000000000000000000..362ec1fb6f24919ca077072286ef40cbeb20baaf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_23.js @@ -0,0 +1,724 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_23", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["gradient", "stroke", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.jshorizontal_bar_proportional_circle_area_chart_04 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- Temporary SVG for column title text measurement (defined early) ---------- + const tempTextSvgForColumnTitles = d3.select(containerSelector) + .append("svg").attr("width", 0).attr("height", 0).style("visibility", "hidden"); + + // ---------- Helper: Estimate Generic Text Width (for column titles) ---------- + const estimateGenericTextWidth_forTitles = (text, fontConfig) => { + return chartUtils.text.measure(tempTextSvgForColumnTitles, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- Helper: Get Wrapped Lines (for column titles) ---------- + function getWrappedLines_forTitles(textContent, availableWidth, fontConfig) { + const words = (textContent || "").trim().split(/\s+/).filter(w => w !== ""); + const lines = []; + const fontSizeValue = parseFloat(fontConfig.font_size); + const lineHeight = fontSizeValue * 1.2; // Estimate line height + + if (words.length === 0) { + return { linesArray: [], numLines: 0, lineHeight: lineHeight }; + } + + // Simplified single word breaking logic (breaks by char if too long) + const breakSingleWord = (word) => { + let currentWordPart = ""; + const wordLines = []; + for (let char of word) { + if (estimateGenericTextWidth_forTitles(currentWordPart + char, fontConfig) > availableWidth && currentWordPart !== "") { + wordLines.push(currentWordPart); + currentWordPart = char; + } else { + currentWordPart += char; + } + } + if (currentWordPart !== "") wordLines.push(currentWordPart); + return wordLines.length > 0 ? wordLines : [word]; // Fallback to original word if wrapping fails + }; + + if (words.length === 1) { + if (estimateGenericTextWidth_forTitles(words[0], fontConfig) > availableWidth) { + lines.push(...breakSingleWord(words[0])); + } else { + lines.push(words[0]); + } + return { linesArray: lines.filter(l=>l), numLines: lines.filter(l=>l).length, lineHeight: lineHeight }; + } + + let currentLine = words[0]; + if (estimateGenericTextWidth_forTitles(currentLine, fontConfig) > availableWidth) { + const brokenFirstWord = breakSingleWord(currentLine); + lines.push(...brokenFirstWord.slice(0, -1)); + currentLine = brokenFirstWord.length > 0 ? brokenFirstWord[brokenFirstWord.length-1] : ""; + } + + for (let i = 1; i < words.length; i++) { + const word = words[i]; + if (estimateGenericTextWidth_forTitles(word, fontConfig) > availableWidth) { // Current word itself is too long + if (currentLine !== "") lines.push(currentLine); + lines.push(...breakSingleWord(word)); + currentLine = ""; + continue; + } + + const testLine = currentLine === "" ? word : currentLine + " " + word; + if (estimateGenericTextWidth_forTitles(testLine, fontConfig) > availableWidth && currentLine !== "") { + lines.push(currentLine); + currentLine = word; + } else { + currentLine = testLine; + } + } + if (currentLine !== "") { + if (estimateGenericTextWidth_forTitles(currentLine, fontConfig) > availableWidth) { + lines.push(...breakSingleWord(currentLine)); + } else { + lines.push(currentLine); + } + } + + return { linesArray: lines.filter(l=>l), numLines: lines.filter(l=>l).length, lineHeight: lineHeight }; + } + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部标题空间 + right: 5, // 右侧边距 + bottom: 40, // 底部边距 + left: 0 // 左侧边距（条形图紧贴左边） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸（便于其他模板复制复用） + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算）（便于其他模板复制复用） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加“-”；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 5. 布局计算 和 字体调整 + const textPadding = 5; // 文本与图标/边缘的间距 + const maxIconSize = 30; // Icon最大尺寸 + const barPadding = 0.2; + const dimLabelMaxWidth = width * 0.2; // 类别label允许占用的最大宽度（按图表总宽度比例） + const dimLabelLineSpacing = 1.01; // 类别label行距系数（尽量紧凑） + + // innerHeight 不依赖 margin.left，可先计算；yScale 用它计算条形高度与条间距（真实barGap） + const innerHeight = height - margin.top - margin.bottom; + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScale.bandwidth(); + const barGap = Math.max(0, yScale.step() - yScale.bandwidth()); // 条形之间的间距 + const maxDimLabelHeight = barHeight + barGap; // 类别label整体高度上限 + + // icon尺寸（按barHeight动态） + const iconSize = calcIconSize(barHeight, { maxSize: maxIconSize, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + + // 类别label布局（统一字号+换行） + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: maxDimLabelHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: Math.min(20, barHeight * 0.6) + }); + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + const maxDimLabelWidth = dimLabelLayout.maxLabelWidth; + + // 更新左边距（使用动态icon尺寸与最大label宽度） + const requiredLeftSpace = maxDimLabelWidth + textPadding + flagWidth + textPadding; + margin.left = requiredLeftSpace + 5; + + // 设置条形图和圆形图的布局比例 + const leftColumnRatio = 0.85; + const rightColumnRatio = 0.15; + + // 计算内部绘图区域尺寸（innerHeight已计算） + const innerWidth = width - margin.left - margin.right; + + // 计算两列的宽度 + const barChartWidth = innerWidth * leftColumnRatio; + const circleChartWidth = innerWidth * rightColumnRatio; + + // X轴比例尺（第一个数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barChartWidth]); + + // 圆形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minRadius = yScale.bandwidth() * 0.3; // 最小半径 + const maxRadius = Math.min(yScale.bandwidth() * 1.0, circleChartWidth*0.5) // 最大半径 + + const radiusScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // 7. 创建SVG容器 ( Titles will be appended to this directly) + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加水平渐变（从左到右，匹配_02.js的最终版本） + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + // 8. 添加标题 (Refactored for wrapping) + const titleFontConfig = typography.description; + const titleBottomPadding = 5; // 标题底部与图表顶部(主绘图区g元素)之间的间距 + const desiredBaselineOfLastLine = margin.top - titleBottomPadding; // g元素上方10px + + // 左侧列标题 + // Note: innerWidth here is calculated based on the dynamic margin.left from _23.js + const leftTitleAvailableWidth = innerWidth * 0.6; + const leftTitleXPos = margin.left; // Starts at the beginning of the main chart content area + const wrappedLeftTitle = getWrappedLines_forTitles(columnTitle1, leftTitleAvailableWidth, titleFontConfig); + + if (wrappedLeftTitle.numLines > 0) { + const initialYLeft = desiredBaselineOfLastLine - (wrappedLeftTitle.numLines - 1) * wrappedLeftTitle.lineHeight; + const leftTitleText = svg.append("text") // Append to svg, not g + .attr("x", leftTitleXPos) + .attr("y", initialYLeft) + .attr("text-anchor", "start") + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedLeftTitle.linesArray.forEach((line, i) => { + leftTitleText.append("tspan") + .attr("x", leftTitleXPos) + .attr("dy", i === 0 ? 0 : wrappedLeftTitle.lineHeight) + .text(line); + }); + } + + // 右侧列标题 + const rightTitleAvailableWidth = innerWidth * 0.4; + const rightTitleXPos = margin.left + innerWidth; // Right edge of the main chart content area + const wrappedRightTitle = getWrappedLines_forTitles(columnTitle2, rightTitleAvailableWidth, titleFontConfig); + + if (wrappedRightTitle.numLines > 0) { + const initialYRight = desiredBaselineOfLastLine - (wrappedRightTitle.numLines - 1) * wrappedRightTitle.lineHeight; + const rightTitleText = svg.append("text") // Append to svg, not g + .attr("x", rightTitleXPos) + .attr("y", initialYRight) + .attr("text-anchor", "end") + .style("font-family", titleFontConfig.font_family) + .style("font-size", titleFontConfig.font_size) + .style("font-weight", titleFontConfig.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + wrappedRightTitle.linesArray.forEach((line, i) => { + rightTitleText.append("tspan") + .attr("x", rightTitleXPos) + .attr("dy", i === 0 ? 0 : wrappedRightTitle.lineHeight) + .text(line); + }); + } + + // Remove the temporary SVG for column title measurement + tempTextSvgForColumnTitles.remove(); + + // ---------- Helper: Estimate Text Width ---------- + const tempTextSvg = svg.append("g").attr("visibility", "hidden"); + const estimateLabelWidth = (text, fontConfig, barHeight) => { + // Calculate dynamic font size for value labels if applicable + const isValueLabel = fontConfig === typography.annotation; + const fontSize = isValueLabel ? `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px` : fontConfig.font_size; + + return chartUtils.text.measure(tempTextSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形描边颜色 (匹配_02.js的最终版本) + const getStrokeColor = (dimension) => { + const baseColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + return colorResolver.variant(baseColor, { mode: "brighter", amount: 3 }); + }; + + // 获取圆形图颜色 + const getCircleColor = (dimension) => { + + return colorResolver.other("secondary", { fallback: "#83C341" }).value; // 亮绿色 + }; + + // 存储第一个条形的宽度，用于后续条形图标签位置决策 + let firstBarWidth = 0; + if (sortedDimensions.length > 0) { + const firstDataPoint = chartData.find(d => d[dimensionField] === sortedDimensions[0]); + if (firstDataPoint) { + firstBarWidth = xScale(+firstDataPoint[valueField1]); + } + } + + // 为每个维度绘制条形和圆形 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+dataPoint[valueField1])); //确保不为负 + + // --- 定义元素位置 (新布局) --- + const labelX = -(flagWidth + textPadding + 5); + const iconX = -flagWidth - 5; + + // 1. 绘制条形 (强制视觉效果) (保持不变) + g.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidthValue) + .attr("height", barHeight) + .attr("fill", "url(#bar-gradient)") // 强制渐变填充 + .attr("rx", barHeight/4) // 强制圆角半径4 + .attr("ry", barHeight/4) // 强制圆角半径4 + .attr("opacity", 0.9); + + // 2. 添加维度标签 (支持多行换行，字符级断行，右对齐) + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", labelX) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + // 多行：使用“y + dy”的方式，和bar内数值label保持同一套定位体系，确保SVG/PNG一致 + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + // 第一行用0.35em把baseline调到视觉居中位置；后续行用像素行高推进 + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + // 单行：与bar内数值label一致（y=centerY + dy=0.35em） + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 3. 添加图标 (新位置, 无裁剪) + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); + + if (images.field && images.field[dimension]) { + // 绘制图片（无边框圆圈） + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + // 不再需要clip-path + } + // 4. 添加条形数值标签 (需要重新评估位置逻辑) + const valueLabelText = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + const currentValueLabelWidth = estimateLabelWidth(valueLabelText, typography.annotation, barHeight); + const valueLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + + // 定位逻辑：优先放内部左侧，如果放不下或者太拥挤，再放外部 + let valueLabelXPos, valueLabelAnchor, valueLabelFill; + const internalPadding = 10; // 内部所需间距 + const externalPadding = 5; // 外部所需间距 + + if (barWidthValue >= currentValueLabelWidth + internalPadding * 2) { + // 空间足够放内部，靠左显示 + valueLabelXPos = internalPadding; // 靠左 + valueLabelAnchor = "start"; + valueLabelFill = "#FFFFFF"; + } else { + // 放外部 + valueLabelXPos = barWidthValue + externalPadding; + valueLabelAnchor = "start"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + } + + g.append("text") + .attr("x", valueLabelXPos) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", valueLabelFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(valueLabelText); + + // 5. 绘制圆形 (保持不变, 但注意其绝对X位置受margin.left影响) + const circleRadius = radiusScale(+dataPoint[valueField2]); + const circleX = barChartWidth + circleChartWidth / 2; + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", getCircleColor(dimension)) + .attr("opacity", 0.6); + + // 6. 添加圆形数值标签 (GDP Value) + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + const circleLabelFontSize = `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", circleLabelFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + + } catch (error) { + console.error(`渲染${dimension}时出错:`, error); + } + }); + + // 移除临时SVG元素 + tempTextSvg.remove(); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_24.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_24.js new file mode 100644 index 0000000000000000000000000000000000000000..dba7c58ac35da4de892ab1ee97237693bbb15668 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_24.js @@ -0,0 +1,397 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_24", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["gradient", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.jshorizontal_bar_proportional_circle_area_chart_05 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 清空容器 + d3.select(containerSelector).html(""); + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部标题空间 + right: 10, // 右侧边距 + bottom: 50, // 底部边距 + left: 0 // 左侧边距（初始值，将根据标签和图标宽度调整） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 5. 布局计算 和 字体调整 + const flagWidth = 30; + const flagHeight = 30; + const textPadding = 5; // 文本与图标/边缘的间距 + const minFontSize = 10; // 最小字体大小 + + let maxDimLabelWidth = 0; + let defaultLabelFontSize = parseFloat(typography.label.font_size); + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${defaultLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + + // 计算可用空间并调整字体大小 + const maxAllowedLabelSpace = width * 0.20; // 允许标签占用的最大宽度比例 + let finalDimLabelFontSize = defaultLabelFontSize; + if (maxDimLabelWidth > maxAllowedLabelSpace) { + const scaleFactor = maxAllowedLabelSpace / maxDimLabelWidth; + finalDimLabelFontSize = Math.max(minFontSize, defaultLabelFontSize * scaleFactor); + // 重新计算调整后的最大宽度 + maxDimLabelWidth = 0; + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${finalDimLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + } + + // 设置各区域宽度 - 更新为 _04.js 的逻辑 + const requiredLeftSpace = maxDimLabelWidth + textPadding + flagWidth + textPadding; + margin.left = requiredLeftSpace + 10; // 增加10px缓冲 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 重新计算圆形图和条形图区域宽度（基于新的innerWidth） + const circleAreaRatio = 0.25; // 圆形区域占内部宽度的比例 + const barAreaRatio = 1 - circleAreaRatio; // 条形区域占内部宽度的比例 + const circleAreaWidth = innerWidth * circleAreaRatio; + const barAreaWidth = innerWidth * barAreaRatio; + + // 6. 创建比例尺 + const barPadding = 0.2; + + // Y轴比例尺（维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（第一个数值）- 范围调整为条形图区域宽度 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barAreaWidth]); // 使用 barAreaWidth + + // 圆形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minRadius = yScale.bandwidth() * 0.3; // 最小半径 + // 调整最大半径以适应 circleAreaWidth + const maxRadius = Math.min(yScale.bandwidth(), circleAreaWidth / 2); // 使用新的 circleAreaWidth + + const radiusScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // 7. 创建SVG容器 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加水平渐变（从左到右） + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + + + // 条形图列标题 - 定位到条形图区域右侧 + svg.append("text") + .attr("x", margin.left + innerWidth) // 定位到内部区域右边缘 + .attr("y", margin.top - 10) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle1); + + // 圆形图列标题 - 定位到圆形图区域中心 + svg.append("text") + .attr("x", margin.left + circleAreaWidth / 2) // 定位到圆形区域中心 + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") // 居中对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // ---------- Helper: Estimate Text Width ---------- + const estimateLabelWidth = (text, fontConfig, barHeight) => { + // Calculate dynamic font size for value labels if applicable + const isValueLabel = fontConfig === typography.annotation; + const fontSize = isValueLabel ? `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px` : fontConfig.font_size; + + return chartUtils.text.measure(svg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 获取条形描边颜色 + const getStrokeColor = (dimension) => { + const baseColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + return colorResolver.variant(baseColor, { mode: "brighter", amount: 3 }); + }; + + // 获取圆形图颜色 + const getCircleColor = (dimension) => { + return colorResolver.other("secondary", { fallback: "#83C341" }).value; // 亮绿色 + }; + + // 为每个维度绘制元素 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+dataPoint[valueField1])); // 确保不为负 + + // --- 重新定义元素位置 (借鉴 _04.js 标签/图标逻辑) --- + // 1. 标签位于 G 元素的左侧 + const labelX = -(flagWidth + textPadding + 5); // 相对 G 的 x 坐标 + // 2. 图标位于 G 元素的左侧，标签右侧 + const iconX = -(flagWidth + 5); // 相对 G 的 x 坐标 + // 3. 圆形图位于内部绘图区域的左侧部分 (circleAreaWidth) + const circleX = circleAreaWidth / 2; // 圆心位于圆形区域中间 + // 4. 条形图位于内部绘图区域的右侧部分 (barAreaWidth)，右对齐 + const barAreaStartX = circleAreaWidth; // 条形区域开始的 X 坐标 (相对 G) + const barX = barAreaStartX + barAreaWidth - barWidthValue; // 条形左上角 X (右对齐) + + // 1. 添加维度标签 (移到左侧) + g.append("text") + .attr("x", labelX) // 使用新的 x 坐标 + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimLabelFontSize}px`) // 使用最终字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 2. 添加图标 (移到左侧) + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); // 使用新的 x 坐标 + + if (images.field && images.field[dimension]) { + // 绘制图片（移除边框圆圈） + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 3. 绘制圆形 - 位置调整到 circleAreaWidth 内 + const circleRadius = radiusScale(+dataPoint[valueField2]); + g.append("circle") + .attr("cx", circleX) // 使用新的 cx + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", getCircleColor(dimension)) + .attr("opacity", 0.6) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1) + .attr("stroke-opacity", 0.5); + + // 4. 添加圆形数值标签 + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + // 动态调整字体大小，确保适合圆圈 + const circleLabelFontSize = Math.min( + 14, + Math.max(10, Math.min(barHeight * 0.5, circleRadius * 0.8)) + ); + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${circleLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + // 5. 绘制条形 - 位置和宽度调整到 barAreaWidth 内，右对齐 + g.append("rect") + .attr("x", barX) // 使用新的 x 坐标 + .attr("y", y) + .attr("width", barWidthValue) // 宽度基于 xScale + .attr("height", barHeight) + .attr("fill", "url(#bar-gradient)") + .attr("rx", barHeight/4) + .attr("ry", barHeight/4) + .attr("opacity", 0.9); + + // 6. 添加条形数值标签 - 根据条形宽度智能放置 (坐标基于新的 barX) + const valueLabelText = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + const currentValueLabelWidth = estimateLabelWidth(valueLabelText, typography.annotation, barHeight); + const valueLabelFontSize = Math.min(16, Math.max(barHeight * 0.5, 12)); + + // 确定标签位置：有足够空间时放在条形内部左侧，否则放在左侧外部 + let valueLabelXPos, valueLabelAnchor, valueLabelFill; + const internalPadding = 10; // 内部所需间距 + const externalPadding = 8; // 外部所需间距 + + if (barWidthValue >= currentValueLabelWidth + internalPadding * 2) { + // 空间足够放内部，靠左显示 + valueLabelXPos = barX + internalPadding; // 基于新的 barX + valueLabelAnchor = "start"; + valueLabelFill = "#FFFFFF"; // 条形内部使用白色文本 + } else { + // 放外部 + valueLabelXPos = barX - externalPadding; // 基于新的 barX + valueLabelAnchor = "end"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + } + + g.append("text") + .attr("x", valueLabelXPos) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(valueLabelText); + + } catch (error) { + console.error(`渲染${dimension}时出错:`, error); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_25.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_25.js new file mode 100644 index 0000000000000000000000000000000000000000..35270ea1a1129d982ce4a5690c7fec5a3440032a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_25.js @@ -0,0 +1,332 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_25", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [ + ["categorical"], + ["numerical"], + ["numerical"] + ], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js 圆在左边 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { // 颜色配置 + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341", secondary: "#FFA500" } // 提供备用颜色 + }; + // const images = jsonData.images || { field: {}, other: {} }; // 不再需要图标配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + // const titles = jsonData.titles || {}; // 标题配置似乎未使用 + + // 设置视觉效果变量 (圆角由代码直接控制，不再需要此变量) + // variables.has_rounded_corners = variables.has_rounded_corners || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部标题空间 + right: 10, // 右侧边距 + bottom: 50, // 底部边距 + left: 10 // 左侧边距（初始值，将根据标签宽度调整） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + const tempSvgForEstimation = d3.select(containerSelector).append("svg").attr("width", 0).attr("height", 0).style("visibility", "hidden"); // 用于估算文本宽度 + + // ---------- Helper: Estimate Text Width ---------- + const estimateLabelWidth = (text, fontConfig, defaultFontSize = 12) => { + const fontSize = fontConfig.font_size || `${defaultFontSize}px`; + const fontFamily = fontConfig.font_family || "Arial"; + const fontWeight = fontConfig.font_weight || "normal"; + + return chartUtils.text.measure(tempSvgForEstimation, text, { + fontFamily, + fontSize, + fontWeight + }).width; + }; + + // 5. 布局计算 + const dimLabelPadding = 10; // 维度标签与左边缘的间距 + const valueLabelExternalPadding = 3; // 数值标签与其对应条形图左侧的间距 + const minFontSize = 10; // 最小字体大小 + const gapBetweenCircleAndBar = 15; // 圆形区域和条形图区域之间的固定间隙 + + // 5.1 计算维度标签所需最大宽度和最终字体大小 + let maxDimLabelWidth = 0; + let defaultLabelFontSize = parseFloat(typography.label.font_size); + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + maxDimLabelWidth = Math.max(maxDimLabelWidth, estimateLabelWidth(labelText, typography.label, defaultLabelFontSize)); + }); + + const maxAllowedLabelSpace = width * 0.20; // 允许标签占用的最大宽度比例 + let finalDimLabelFontSize = defaultLabelFontSize; + if (maxDimLabelWidth > maxAllowedLabelSpace) { + const scaleFactor = maxAllowedLabelSpace / maxDimLabelWidth; + finalDimLabelFontSize = Math.max(minFontSize, defaultLabelFontSize * scaleFactor); + // 重新计算调整后的最大宽度 + maxDimLabelWidth = 0; + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + maxDimLabelWidth = Math.max(maxDimLabelWidth, estimateLabelWidth(labelText, typography.label, finalDimLabelFontSize)); + }); + } + tempSvgForEstimation.remove(); // 移除临时SVG + + // 5.2 设置最终边距和内部尺寸 + const requiredLeftSpace = maxDimLabelWidth + dimLabelPadding; // 仅需要标签宽度和内边距 + margin.left = requiredLeftSpace + 10; // 增加10px缓冲 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 5.3 划分内部绘图区域宽度 (圆形区 + 间隙 + 条形区) + const circleAreaRatio = 0.25; // 圆形区域占内部宽度的比例 (相对于总innerWidth) + const circleAreaWidth = innerWidth * circleAreaRatio; // 圆形区域宽度 + let barAreaWidth = innerWidth - circleAreaWidth - gapBetweenCircleAndBar; // 剩余给条形图的宽度 + + // 确保条形图区域有最小宽度 + const minBarWidth = 10; + if (barAreaWidth < minBarWidth) { + console.warn(`计算出的条形图区域宽度 (${barAreaWidth}px) 过小，已调整为最小值 ${minBarWidth}px。可能导致元素重叠或显示不佳。`); + barAreaWidth = minBarWidth; + } + + // 6. 创建比例尺 + const barPadding = 0.2; + + // Y轴比例尺（维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（第一个数值）- 范围是调整后的 barAreaWidth + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barAreaWidth]); // 使用调整后的 barAreaWidth + + // 圆形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minRadius = yScale.bandwidth() * 0.3; // 最小半径 + const maxRadius = Math.min(yScale.bandwidth() * 0.45, circleAreaWidth / 2 - 5); // 避免贴边 + const radiusScale = d3.scaleSqrt() + .domain([0, maxValue2]) + .range([minRadius, maxRadius]); + + // 7. 创建SVG容器 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 8. 绘制标题和坐标轴标签 (如果有) + // 条形图列标题 - 定位到内部区域最右边缘 + svg.append("text") + .attr("x", margin.left + innerWidth) // 定位到内部区域右边缘 + .attr("y", margin.top - 10) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle1); + + // 圆形图列标题 - 定位到圆形图区域中心 + svg.append("text") + .attr("x", margin.left + circleAreaWidth / 2) // 定位到圆形区域中心 + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") // 居中对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // ---------- Helper: Get Bar Color ---------- + const getBarColor = (dimension) => { + return (colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value) ? colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value : (colorResolver.other("primary", { fallback: "#83C341" }).value); + }; + + // ---------- Helper: Get Stroke Color ---------- + const getStrokeColor = (dimension) => { + const baseColor = getBarColor(dimension); + try { + return colorResolver.variant(baseColor, { mode: "brighter", amount: 3 }); + } catch (error) { + console.warn(`无法生成维度 ${dimension} 的描边颜色 (基础颜色: ${baseColor}): `, error); + return baseColor; + } + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 为每个维度绘制元素 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { console.error(`找不到维度的数据: ${dimension}`); return; } + + const value1 = +dataPoint[valueField1]; + const value2 = +dataPoint[valueField2]; + if (isNaN(value1) || isNaN(value2)) { console.error(`${dimension} 的数据值无效: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); return; } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { console.error(`维度 ${dimension} 的y坐标无效`); return; } + + const centerY = y + barHeight / 2; + + // --- 定义元素 X 坐标 (基于动态计算) --- + const dimensionLabelX = -dimLabelPadding; // 维度标签 X (右边缘) + const circleX = circleAreaWidth / 2; // 圆心 X + const barAreaStartX = circleAreaWidth + gapBetweenCircleAndBar; // 条形图区域起始 X + const barWidthValue = Math.max(0, xScale(value1)); // 条形图宽度 + const barX = barAreaStartX + barAreaWidth - barWidthValue; // 条形图左上角 X (在 barArea 内右对齐) + const valueLabelXPos = barX - valueLabelExternalPadding; // 数值标签 X (右边缘), 紧邻条形左侧 + + // 1. 添加维度标签 + g.append("text") + .attr("x", dimensionLabelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimLabelFontSize}px`) // 使用最终字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 2. 绘制圆形 + const circleRadius = radiusScale(value2); + const circleFillColor = (colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value) ? colorResolver.field(dimension, 0, { fallbackKey: "primary" }).value : (colorResolver.other("secondary", { fallback: "#A9A9A9" }).value); + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", circleFillColor) + .attr("opacity", 0.6) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1) + .attr("stroke-opacity", 0.5); + + // 3. 添加圆形数值标签 + const formattedValue2 = `${chartUtils.format.autoText(value2)}${valueUnit2}`; + const circleLabelFontSize = Math.min(14, Math.max(10, Math.min(barHeight * 0.4, circleRadius * 0.8))); + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${circleLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue2); + + // 4. 绘制条形 + const barFillColor = getBarColor(dimension); + g.append("rect") + .attr("x", barX) + .attr("y", y) + .attr("width", barWidthValue) + .attr("height", barHeight) + .attr("fill", barFillColor) + .attr("rx", barHeight * 0.5) // 半圆角 + .attr("ry", barHeight * 0.5) // 半圆角 + .attr("opacity", 0.9) + .style("stroke", getStrokeColor(dimension)) // 描边 + .style("stroke-width", 1); + + // 5. 添加条形数值标签 (位置相对条形) + const valueLabelText = `${chartUtils.format.autoText(value1)}${valueUnit1}`; + const valueLabelFontSize = Math.min(16, Math.max(barHeight * 0.5, 12)); + g.append("text") + .attr("x", valueLabelXPos) // 使用相对条形的X坐标 + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 文本右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 固定使用默认文本颜色 + .text(valueLabelText); + + } catch (error) { + console.error(`渲染维度 ${dimension} 时出错:`, error); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_26.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_26.js new file mode 100644 index 0000000000000000000000000000000000000000..9b51047def1a7c601fca54642ee8133be76106a5 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_26.js @@ -0,0 +1,434 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_26", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [["categorical"], ["numerical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["gradient", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例圆复合图表实现 - 使用D3.js horizontal_bar_proportional_circle_area_chart_05 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 清空容器 + d3.select(containerSelector).html(""); + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部标题空间 + right: 10, // 右侧边距 + bottom: 50, // 底部边距 + left: 0 // 左侧边距（初始值，将根据标签和图标宽度调整） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 5. 布局计算 和 字体调整 + const flagWidth = 30; + const flagHeight = 30; + const textPadding = 5; // 文本与图标/边缘的间距 + const minFontSize = 10; // 最小字体大小 + + let maxDimLabelWidth = 0; + let defaultLabelFontSize = parseFloat(typography.label.font_size); + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${defaultLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + + // 计算可用空间并调整字体大小 + const maxAllowedLabelSpace = width * 0.20; // 允许标签占用的最大宽度比例 + let finalDimLabelFontSize = defaultLabelFontSize; + if (maxDimLabelWidth > maxAllowedLabelSpace) { + const scaleFactor = maxAllowedLabelSpace / maxDimLabelWidth; + finalDimLabelFontSize = Math.max(minFontSize, defaultLabelFontSize * scaleFactor); + // 重新计算调整后的最大宽度 + maxDimLabelWidth = 0; + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${finalDimLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + } + + // 设置各区域宽度 - 更新为 _04.js 的逻辑 + const requiredLeftSpace = maxDimLabelWidth + textPadding + flagWidth + textPadding; + margin.left = requiredLeftSpace + 10; // 增加10px缓冲 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 重新计算圆形图和条形图区域宽度（基于新的innerWidth） + const circleAreaRatio = 0.25; // 圆形区域占内部宽度的比例 + const barAreaRatio = 1 - circleAreaRatio; // 条形区域占内部宽度的比例 + const circleAreaWidth = innerWidth * circleAreaRatio; + const barAreaWidth = innerWidth * barAreaRatio; + + // 6. 创建比例尺 + const barPadding = 0.2; + + // Y轴比例尺（维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（第一个数值）- 范围调整为条形图区域宽度 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, barAreaWidth]); // 使用 barAreaWidth + + // 正方形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minSide = yScale.bandwidth() * 0.05; // 最小边长 + // 调整最大边长以适应 squareAreaWidth 和条目高度 + const maxSide = Math.min(yScale.bandwidth() * 1.8, circleAreaWidth); // 使用新的 circleAreaWidth (现在代表正方形区域宽度) + + const sideScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minSide, maxSide]); + + // 7. 创建SVG容器 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + + + // --- 为每个唯一条形图颜色定义渐变 --- + const uniqueBarColors = [...new Set(chartData.map(d => { + const dimension = d[dimensionField]; + const defaultBarColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + return colorResolver.field(dimension, 0, { fallback: defaultBarColor }).value; + }))]; + + uniqueBarColors.forEach(barColor => { + // 清理颜色值以用作ID (移除#和任何非字母数字字符) + const gradientId = `bar-gradient-${barColor.replace(/[^a-zA-Z0-9]/g, '')}`; + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") // 水平渐变 + .attr("y2", "0%"); + + // 定义渐变，中间最亮，两边较暗 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.5 })); // 可以调整暗度 + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 1.5 })); // 可以调整亮度 + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.5 })); // 与起始点相同暗度 + }); + // --- 渐变定义结束 --- + + + // 条形图列标题 - 定位到条形图区域右侧 + svg.append("text") + .attr("x", margin.left + innerWidth) // 定位到内部区域右边缘 + .attr("y", margin.top - 10) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle1); + + // 正方形图列标题 - 定位到正方形图区域中心 + svg.append("text") + .attr("x", margin.left + circleAreaWidth / 2) // 定位到正方形区域中心 + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") // 居中对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // ---------- Helper: Estimate Text Width ---------- + const estimateLabelWidth = (text, fontConfig, barHeight) => { + // Calculate dynamic font size for value labels if applicable + const isValueLabel = fontConfig === typography.annotation; + const fontSize = isValueLabel ? `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px` : fontConfig.font_size; + + return chartUtils.text.measure(svg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 为每个维度绘制元素 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+dataPoint[valueField1])); // 确保不为负 + + // --- 重新定义元素位置 (借鉴 _04.js 标签/图标逻辑) --- + // 1. 标签位于 G 元素的左侧 + const labelX = -(flagWidth + textPadding + 5); // 相对 G 的 x 坐标 + // 2. 图标位于 G 元素的左侧，标签右侧 + const iconX = -(flagWidth + 5); // 相对 G 的 x 坐标 + // 3. 正方形图位于内部绘图区域的左侧部分 (circleAreaWidth) + const squareAreaCenterX = circleAreaWidth / 2; // 正方形区域中心 X 坐标 + // 4. 条形图位于内部绘图区域的右侧部分 (barAreaWidth)，右对齐 + const barAreaStartX = circleAreaWidth; // 条形区域开始的 X 坐标 (相对 G) + const barX = barAreaStartX + barAreaWidth - barWidthValue; // 条形左上角 X (右对齐) + + // 1. 添加维度标签 (移到左侧) + g.append("text") + .attr("x", labelX) // 使用新的 x 坐标 + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimLabelFontSize}px`) // 使用最终字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 2. 添加图标 (移到左侧) + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${centerY - flagHeight/2})`); // 使用新的 x 坐标 + + if (images.field && images.field[dimension]) { + // 绘制图片（移除边框圆圈） + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 3. 绘制正方形 - 位置调整到 circleAreaWidth (正方形区域) 内 + const squareSide = sideScale(+dataPoint[valueField2]); + const squareX = squareAreaCenterX - squareSide / 2; // 正方形左上角 x + const squareY = centerY - squareSide / 2; // 正方形左上角 y + + // --- 确定颜色 --- + const defaultBarColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + const defaultSquareColor = colorResolver.other("secondary", { fallback: "#57A0D3" }).value; // 使用不同的默认色以区分 + const barColor = colorResolver.field(dimension, 0, { fallback: defaultBarColor }).value; + const squareColor = colorResolver.field(dimension, 0, { fallback: defaultSquareColor }).value; + // --- 确定颜色结束 --- + + g.append("rect") // 绘制矩形代表正方形 + .attr("x", squareX) + .attr("y", squareY) + .attr("width", squareSide) + .attr("height", squareSide) + .attr("fill", squareColor) // 使用维度特定颜色 + .attr("opacity", 0.7) // 轻微调整不透明度以便区分 + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1) + .attr("stroke-opacity", 0.5); + + // 4. 添加正方形数值标签 - 根据大小决定位置和颜色 + const formattedValue2 = `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}`; + // 动态调整字体大小，确保适合正方形 + const squareLabelFontSize = Math.min( + 16, + Math.max(12, Math.min(barHeight * 0.5, squareSide * 0.7)) // 基于 squareSide 调整 + ); + + // 定义标签位置和颜色的阈值 + const labelPositionThreshold = barHeight * 0.4; // 当边长大于此值时，标签在内部 + let squareLabelFill, squareLabelX, squareLabelY, squareLabelAnchor, squareLabelDy; + + if (squareSide >= labelPositionThreshold) { + // 大正方形：标签在内部，白色 + squareLabelFill = "#FFFFFF"; + squareLabelX = squareAreaCenterX; + squareLabelY = centerY; + squareLabelAnchor = "middle"; + squareLabelDy = "0.35em"; + } else { + // 小正方形：标签在上方，与正方形同色 + squareLabelFill = squareColor; // 使用正方形的颜色 + squareLabelX = squareAreaCenterX; + squareLabelY = squareY - 5; // 放置在正方形顶部上方一点 + squareLabelAnchor = "middle"; + squareLabelDy = "0em"; // 基线对齐 + } + + g.append("text") + .attr("x", squareLabelX) // 使用计算出的 X + .attr("y", squareLabelY) // 使用计算出的 Y + .attr("dy", squareLabelDy) // 使用计算出的 dy + .attr("text-anchor", squareLabelAnchor) // 使用计算出的 text-anchor + .style("font-family", typography.annotation.font_family) + .style("font-size", `${squareLabelFontSize}px`) // 使用新的字体大小 + .style("font-weight", typography.annotation.font_weight) + .style("fill", squareLabelFill) // 使用计算出的 fill + .text(formattedValue2); + + // 5. 绘制条形 - 位置和宽度调整到 barAreaWidth 内，右对齐 + g.append("rect") + .attr("x", barX) // 使用新的 x 坐标 + .attr("y", y) + .attr("width", barWidthValue) // 宽度基于 xScale + .attr("height", barHeight) + // .attr("fill", barColor) // 移除直接颜色填充 + .attr("fill", `url(#bar-gradient-${barColor.replace(/[^a-zA-Z0-9]/g, '')})`) // 应用对应的渐变 + .attr("rx", barHeight/8) + .attr("ry", barHeight/8) + .attr("opacity", 0.9); + // .attr("stroke", colorResolver.variant(barColor, { mode: "brighter", amount: 1 })) // 可选：添加基于填充色的描边 + // .attr("stroke-width", 1); + + // 6. 添加条形数值标签 - 根据条形宽度智能放置 (坐标基于新的 barX) + const valueLabelText = `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}`; + const currentValueLabelWidth = estimateLabelWidth(valueLabelText, typography.annotation, barHeight); + const valueLabelFontSize = Math.min(16, Math.max(barHeight * 0.5, 12)); + + // 确定标签位置：有足够空间时放在条形内部左侧，否则放在左侧外部 + let valueLabelXPos, valueLabelAnchor, valueLabelFill; + const internalPadding = 10; // 内部所需间距 + const externalPadding = 8; // 外部所需间距 + + if (barWidthValue >= currentValueLabelWidth + internalPadding * 2) { + // 空间足够放内部，靠左显示 + valueLabelXPos = barX + internalPadding; // 基于新的 barX + valueLabelAnchor = "start"; + valueLabelFill = "#FFFFFF"; // 条形内部使用白色文本 + } else { + // 放外部 + valueLabelXPos = barX - externalPadding; // 基于新的 barX + valueLabelAnchor = "end"; + valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; + } + + g.append("text") + .attr("x", valueLabelXPos) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(valueLabelText); + + } catch (error) { + console.error(`渲染${dimension}时出错:`, error); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_27.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_27.js new file mode 100644 index 0000000000000000000000000000000000000000..437bc566d2a4379ec20afa29d4fe7b832d0798b9 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_27.js @@ -0,0 +1,435 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart With Circle", + "chart_name": "horizontal_bar_chart_27", + "is_composite": true, + "required_fields": ["x", "y", "y2"], + "required_fields_type": [["categorical"],["numerical"],["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["gradient", "radius_corner"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图与比例正方形复合图表实现 - 使用D3.js horizontal_bar_proportional_square_area_chart (基于 26 修改) +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // 1. 数据准备 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#FFFFFF", + background_color: "#0A3B39", + other: { primary: "#83C341" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像配置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 清空容器 + d3.select(containerSelector).html(""); + + // 2. 尺寸和布局设置 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部标题空间 + right: 10, // 右侧边距 + bottom: 50, // 底部边距 + left: 0 // 左侧边距（初始值，将根据标签和图标宽度调整） + }; + + // 3. 提取字段名和单位 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "Country"; + const valueField1 = chartUtils.schema.channel(jsonData, "y").key || "Crypto Ownership Percentage"; + const valueField2 = chartUtils.schema.channel(jsonData, "y2").key || "Number of Owners"; + + // 获取字段单位 + let valueUnit1 = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + let valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none"? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + valueUnit1 = valueUnit1 ? valueUnit1 : ""; + valueUnit2 = valueUnit2 ? valueUnit2 : ""; + + // 列标题 + const columnTitle1 = chartUtils.schema.channel(jsonData, "y").key || + "Crypto Ownership Percentage"; + const columnTitle2 = chartUtils.schema.channel(jsonData, "y2").key || + "Number of Owners"; + + // 4. 数据处理 + const sortedData = [...chartData].sort((a, b) => b[valueField1] - a[valueField1]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 5. 布局计算 和 字体调整 + const flagWidth = 30; + const flagHeight = 30; + const textPadding = 5; // 文本与图标/边缘的间距 + const minFontSize = 10; // 最小字体大小 + + let maxDimLabelWidth = 0; + let defaultLabelFontSize = parseFloat(typography.label.font_size); + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${defaultLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + + // 计算可用空间并调整字体大小 + const maxAllowedLabelSpace = width * 0.20; // 允许标签占用的最大宽度比例 + let finalDimLabelFontSize = defaultLabelFontSize; + if (maxDimLabelWidth > maxAllowedLabelSpace) { + const scaleFactor = maxAllowedLabelSpace / maxDimLabelWidth; + finalDimLabelFontSize = Math.max(minFontSize, defaultLabelFontSize * scaleFactor); + // 重新计算调整后的最大宽度 + maxDimLabelWidth = 0; + sortedDimensions.forEach(dimension => { + const labelText = dimension.toUpperCase(); + const textWidth = chartUtils.text.measure(null, labelText, { + fontFamily: typography.label.font_family, + fontSize: `${finalDimLabelFontSize}px`, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + } + + // 设置各区域宽度 - 移除图标空间 + const requiredLeftSpace = maxDimLabelWidth + textPadding; // 只需标签和边距 + margin.left = requiredLeftSpace ; // 增加10px缓冲 + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 重新计算圆形图和条形图区域宽度（基于新的innerWidth） + const circleAreaRatio = 0.25; // 圆形区域占内部宽度的比例 + const barAreaRatio = 1 - circleAreaRatio; // 条形区域占内部宽度的比例 + const circleAreaWidth = innerWidth * circleAreaRatio; + const barAreaWidth = innerWidth * barAreaRatio; + + // 6. 创建比例尺 + const barPadding = 0.2; + + // Y轴比例尺（维度） - 先定义 yScale 以计算 barHeight + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // 计算 barHeight 和 valueLabelFontSize 以便估算宽度 + const barHeight = yScale.bandwidth(); + const valueLabelFontSize = Math.min(20, Math.max(barHeight * 0.5, 12)); + + // 4.3 测量数值标签的最大宽度 + const valueWidths = sortedData.map(d => { + return chartUtils.text.measure(null, `${chartUtils.format.autoText(+d[valueField1])}${valueUnit1}`, { + fontFamily: typography.annotation.font_family, + fontSize: `${valueLabelFontSize}px`, + fontWeight: typography.annotation.font_weight + }).width; + }); + + // 计算条形图可用的实际宽度 + const availableBarWidth = Math.max(0, barAreaWidth - valueWidths[0] - textPadding); + + // X轴比例尺（第一个数值）- 范围调整为 availableBarWidth + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField1]) * 1.05]) // 添加5%边距 + .range([0, availableBarWidth]); // 使用调整后的可用宽度 + + // 正方形面积比例尺（第二个数值） + const maxValue2 = d3.max(chartData, d => +d[valueField2]); + const minSide = yScale.bandwidth() * 0.05; // 最小边长 + // 调整最大边长以适应 squareAreaWidth 和条目高度 + const maxSide = Math.min(yScale.bandwidth() * 1.8, circleAreaWidth); // 使用新的 circleAreaWidth (现在代表正方形区域宽度) + + const sideScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxValue2]) + .range([minSide, maxSide]); + + // 7. 创建SVG容器 + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#83C341" }).value; + const secondaryColor = colorResolver.other("secondary", { fallback: "#57A0D3" }).value; + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + + + // --- 移除渐变定义代码 --- + /* + // --- 为每个唯一条形图颜色定义渐变 (基于维度颜色或 secondaryColor) --- + const uniqueBarColors = [...new Set(chartData.map(d => { + const dimension = d[dimensionField]; + // 后备颜色使用 secondaryColor + return colorResolver.field(dimension, 0, { fallback: secondaryColor }).value; + }))]; + + uniqueBarColors.forEach(barColor => { + // 清理颜色值以用作ID (移除#和任何非字母数字字符) + const gradientId = `bar-gradient-${barColor.replace(/[^a-zA-Z0-9]/g, '')}`; + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") // 水平渐变 + .attr("y2", "0%"); + + // 定义渐变，中间最亮，两边较暗 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.5 })); // 可以调整暗度 + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 1.5 })); // 可以调整亮度 + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.5 })); // 与起始点相同暗度 + }); + // --- 渐变定义结束 --- + */ + + // 条形图列标题 - 定位到条形图区域右侧 + svg.append("text") + .attr("x", margin.left + innerWidth) // 定位到内部区域右边缘 + .attr("y", margin.top - 10) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle1); + + // 正方形图列标题 - 定位到正方形图区域中心 + svg.append("text") + .attr("x", margin.left + circleAreaWidth / 2) // 定位到正方形区域中心 + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") // 居中对齐 + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(columnTitle2); + + // ---------- Helper: Estimate Text Width ---------- + const estimateLabelWidth = (text, fontConfig, barHeight) => { + // Calculate dynamic font size for value labels if applicable + const isValueLabel = fontConfig === typography.annotation; + const fontSize = isValueLabel ? `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px` : fontConfig.font_size; + + return chartUtils.text.measure(svg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + }; + + // ---------- 9. 创建主图表组 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制元素 ---------- + + // 获取条形图颜色的辅助函数 + const getBarColor = (dimension) => { + return colorResolver.field(dimension, 0, { fallback: secondaryColor }).value; + }; + + // 获取描边颜色的辅助函数 (来自用户) + const getStrokeColor = (dimension) => { + // 获取条形的基础颜色 + const baseColor = getBarColor(dimension); + // 返回该颜色的更亮版本 + return colorResolver.variant(baseColor, { mode: "brighter", amount: 3 }); + }; + + // 为每个维度绘制元素 + sortedDimensions.forEach((dimension, index) => { + try { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (!dataPoint) { + console.error(`No data found for dimension: ${dimension}`); + return; + } + + // 检查数据值是否有效 + if (isNaN(+dataPoint[valueField1]) || isNaN(+dataPoint[valueField2])) { + console.error(`Invalid data values for ${dimension}: ${dataPoint[valueField1]}, ${dataPoint[valueField2]}`); + return; + } + + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + if (typeof y !== 'number') { + console.error(`Invalid y position for dimension: ${dimension}`); + return; + } + + const centerY = y + barHeight / 2; + const barWidthValue = Math.max(0, xScale(+dataPoint[valueField1])); // 确保不为负 + + // --- 重新定义元素位置 (无图标) --- + // 1. 标签位于 G 元素的左侧 + const labelX = -(textPadding); // 相对 G 的 x 坐标 (无图标宽度) + // 2. 正方形图位于内部绘图区域的左侧部分 (circleAreaWidth) + const squareAreaCenterX = circleAreaWidth / 2; // 正方形区域中心 X 坐标 + // 3. 条形图位于内部绘图区域的右侧部分 (barAreaWidth)，右对齐 + const barAreaStartX = circleAreaWidth; // 条形区域开始的 X 坐标 (相对 G) + const barX = barAreaStartX + barAreaWidth - barWidthValue; // 条形左上角 X (右对齐) + + // 1. 添加维度标签 (移到左侧) + g.append("text") + .attr("x", labelX) // 使用新的 x 坐标 + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${finalDimLabelFontSize}px`) // 使用最终字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension.toUpperCase()); + + // 3. 绘制正方形 - 位置调整到 circleAreaWidth (正方形区域) 内 + const squareSide = sideScale(+dataPoint[valueField2]); + const squareX = squareAreaCenterX - squareSide / 2; // 正方形左上角 x + const squareY = centerY - squareSide / 2; // 正方形左上角 y + + // --- 确定颜色 (正方形固定 primary, 条形图基于维度或 secondary) --- + // const barColor = getBarColor(dimension); // 在绘制时获取 + // const squareColor = primaryColor; // 正方形颜色直接使用 primaryColor + // --- 颜色确定结束 --- + + g.append("rect") // 绘制矩形代表正方形 + .attr("x", squareX) + .attr("y", squareY) + .attr("width", squareSide) + .attr("height", squareSide) + .attr("fill", primaryColor) // 使用 primary 颜色 + .attr("opacity", 0.7) // 轻微调整不透明度以便区分 + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1) + .attr("stroke-opacity", 0.5); + + // 4. 添加正方形数值标签 - 根据大小决定位置和颜色 + const formattedValue2 = valueUnit2 ? + `${chartUtils.format.autoText(+dataPoint[valueField2])}${valueUnit2}` : + `${chartUtils.format.autoText(+dataPoint[valueField2])}`; + // 动态调整字体大小，确保适合正方形 + const squareLabelFontSize = Math.min( + 16, + Math.max(12, Math.min(barHeight * 0.5, squareSide * 0.7)) // 基于 squareSide 调整 + ); + + // 定义标签位置和颜色的阈值 + const labelPositionThreshold = barHeight * 0.4; // 当边长大于此值时，标签在内部 + let squareLabelFill, squareLabelX, squareLabelY, squareLabelAnchor, squareLabelDy; + + if (squareSide >= labelPositionThreshold) { + // 大正方形：标签在内部，白色 + squareLabelFill = "#FFFFFF"; + squareLabelX = squareAreaCenterX; + squareLabelY = centerY; + squareLabelAnchor = "middle"; + squareLabelDy = "0.35em"; + } else { + // 小正方形：标签在上方，与正方形同色 + squareLabelFill = primaryColor; // 使用 primary 颜色 + squareLabelX = squareAreaCenterX; + squareLabelY = squareY - 5; // 放置在正方形顶部上方一点 + squareLabelAnchor = "middle"; + squareLabelDy = "0em"; // 基线对齐 + } + + g.append("text") + .attr("x", squareLabelX) // 使用计算出的 X + .attr("y", squareLabelY) // 使用计算出的 Y + .attr("dy", squareLabelDy) // 使用计算出的 dy + .attr("text-anchor", squareLabelAnchor) // 使用计算出的 text-anchor + .style("font-family", typography.annotation.font_family) + .style("font-size", `${squareLabelFontSize}px`) // 使用新的字体大小 + .style("font-weight", typography.annotation.font_weight) + .style("fill", squareLabelFill) // 使用计算出的 fill + .text(formattedValue2); + + // 5. 绘制条形 - 位置和宽度调整到 barAreaWidth 内，右对齐 + const barColor = getBarColor(dimension); // 获取当前 bar 颜色 + const strokeColor = getStrokeColor(dimension); // 获取当前 stroke 颜色 + + g.append("rect") + .attr("x", barX) // 使用新的 x 坐标 + .attr("y", y) + .attr("width", barWidthValue) // 宽度基于 xScale + .attr("height", barHeight) + .attr("fill", barColor) // 直接使用 barColor 填充 + .attr("stroke", strokeColor) // 添加描边颜色 + .attr("stroke-width", 1.5) // 设置描边宽度 + .attr("rx", barHeight/8) + .attr("ry", barHeight/8) + .attr("opacity", 0.9); + + // 6. 添加条形数值标签 - 固定放在条形左侧外部 + const formattedValue1 = valueUnit1 ? + `${chartUtils.format.autoText(+dataPoint[valueField1])}${valueUnit1}` : + `${chartUtils.format.autoText(+dataPoint[valueField1])}`; + const valueLabelXPos = barX - textPadding; // 固定在条形左侧 + const valueLabelAnchor = "end"; // 右对齐 + const valueLabelFill = colorResolver.text({ fallback: "#333333" }).value; // 固定文本颜色 + + g.append("text") + .attr("x", valueLabelXPos) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueLabelFontSize}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(formattedValue1); + + } catch (error) { + console.error(`渲染${dimension}时出错:`, error); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_28.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_28.js new file mode 100644 index 0000000000000000000000000000000000000000..ecea752f074ac8d0e24ffe619114cdea5c189dcc --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_28.js @@ -0,0 +1,588 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_28", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "gradient", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + + // 提取维度字段 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + + // 获取数据维度数量 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const dimensionCount = dimensions.length; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 120, // 右侧足够显示标签 + bottom: 60, // 底部边距 + left: 100 // 左侧空间 + }; + + // 计算每个条形的理想高度 - 最小为64像素，最大为128像素 + const MIN_BAR_HEIGHT = 64; + const MAX_BAR_HEIGHT = 128; + const barPadding = variables.has_spacing ? 20 : 10; + + // 计算条形高度，使用合理的默认值 + const barHeight = Math.min(MAX_BAR_HEIGHT, Math.max(MIN_BAR_HEIGHT, 80)); // 默认80像素高 + + // 计算总的条形空间需求 + const totalBarSpace = (barHeight + barPadding) * dimensionCount; + + // 计算图表所需的最小高度 (条形总高度 + 标题和底部的空间) + const extraSpace = 150; // 为标题和底部空间预留的额外高度 + const minHeight = variables.min_height || 400; + const calculatedHeight = Math.max(minHeight, totalBarSpace + extraSpace); + + // 使用计算值或用户指定值作为最终高度 + const height = variables.height || calculatedHeight; + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 根据实际可用空间，可能需要调整条形高度 + const availableHeight = innerHeight - 50; // 保留一些间距 + const adjustedBarHeight = Math.min( + barHeight, + Math.max(MIN_BAR_HEIGHT, availableHeight / dimensionCount) + ); + + // 使用调整后的条形高度 + const finalBarHeight = adjustedBarHeight; + const totalBarSpaceAdjusted = (finalBarHeight + barPadding) * dimensionCount; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算图标尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算智能换行标签布局 ---------- + + // 提取label字体的基础尺寸 + const labelFontSizeNum = parseInt(typography.label.font_size) || 12; + + // 调用智能换行布局计算 + const labelLayout = buildDimLabelLayout({ + containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: 150, + maxHeight: finalBarHeight, + lineSpacing: 1.2, + targetFontSize: labelFontSizeNum + }); + + const dimLabelConfig = labelLayout.dimLabelConfig; + const maxLabelWidth = labelLayout.maxLabelWidth; + + // 根据标签宽度调整边距 + margin.right = Math.max(margin.right, maxLabelWidth + 30); + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barScalePadding = variables.has_spacing ? 0.3 : 0.2; + + // 计算实际需要的总高度（基于调整后的条形高度） + const actualNeededHeight = (finalBarHeight + barPadding) * dimensionCount; + + // 确保Y轴比例尺使用基于finalBarHeight计算的适当范围 + // 如果actualNeededHeight小于innerHeight，则居中显示 + const yAxisStart = Math.max(0, (innerHeight - actualNeededHeight) / 2); + const yAxisEnd = Math.min(innerHeight, yAxisStart + actualNeededHeight); + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([yAxisStart, yAxisEnd]) + .padding(barScalePadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + // 绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barBandHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + const y = yScale(dimension); + const centerY = y + barBandHeight / 2; + + // 创建条形组 + const barGroup = g.append("g"); + + // 绘制矩形条形（没有圆角和边框） + barGroup.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidth) + .attr("height", barBandHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 准备图标尺寸 + const iconSize = barBandHeight * 0.7; + const iconX = 0; + const iconY = y + (barBandHeight - iconSize) / 2; + + // 添加图标（如果有）- 带白色圆形背景 + if (images.field && images.field[dimension]) { + // 添加白色圆形背景 + barGroup.append("circle") + .attr("cx", iconX + iconSize/2) + .attr("cy", iconY + iconSize/2) + .attr("r", iconSize/2) + .attr("fill", "white"); + + // 添加图标 + barGroup.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 格式化数值用于显示 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${barBandHeight * 0.6}px`; + + // 创建临时文本测量数值标签宽度（使用动态字体大小） + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: dynamicFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断数值标签是否能放入条形内 + const labelFitsInside = valueTextWidth + 10 < barWidth; + + // 添加数值标签（使用动态字体大小） + if (labelFitsInside) { + // 标签放在条形内部 + barGroup.append("text") + .attr("x", barWidth - 5) + .attr("y", y + barBandHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色 + .text(formattedValue); + } else { + // 标签放在条形外部 + barGroup.append("text") + .attr("x", barWidth + 5) + .attr("y", y + barBandHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用文本颜色 + .text(formattedValue); + } + + // 添加维度标签（支持多行换行） + const labelConfig = dimLabelConfig[dimension]; + const labelX = barWidth + (labelFitsInside ? 5 : valueTextWidth + 15); + const labelGroup = barGroup.append("text") + .attr("x", labelX) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 在第一个条形上显示单位（如果有） + if (index === 0 && valueUnit) { + barGroup.append("text") + .attr("x", barWidth) + .attr("y", y - 5) // 条形顶部上方 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`(${valueUnit})`); + } + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_29.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_29.js new file mode 100644 index 0000000000000000000000000000000000000000..535256b7b3a2d7b66a3f48b0f3f8510165820590 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_29.js @@ -0,0 +1,589 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_29", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "gradient", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "dark", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors_dark || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + + // 提取维度字段 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + + // 获取数据维度数量 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const dimensionCount = dimensions.length; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 120, // 右侧足够显示标签 + bottom: 60, // 底部边距 + left: 100 // 左侧空间 + }; + + // 计算每个条形的理想高度 - 最小为64像素，最大为128像素 + const MIN_BAR_HEIGHT = 64; + const MAX_BAR_HEIGHT = 128; + const barPadding = variables.has_spacing ? 20 : 10; + + // 计算条形高度，使用合理的默认值 + const barHeight = Math.min(MAX_BAR_HEIGHT, Math.max(MIN_BAR_HEIGHT, 80)); // 默认80像素高 + + // 计算总的条形空间需求 + const totalBarSpace = (barHeight + barPadding) * dimensionCount; + + // 计算图表所需的最小高度 (条形总高度 + 标题和底部的空间) + const extraSpace = 150; // 为标题和底部空间预留的额外高度 + const minHeight = variables.min_height || 400; + const calculatedHeight = Math.max(minHeight, totalBarSpace + extraSpace); + + // 使用计算值或用户指定值作为最终高度 + const height = variables.height || calculatedHeight; + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 根据实际可用空间，可能需要调整条形高度 + const availableHeight = innerHeight - 50; // 保留一些间距 + const adjustedBarHeight = Math.min( + barHeight, + Math.max(MIN_BAR_HEIGHT, availableHeight / dimensionCount) + ); + + // 使用调整后的条形高度 + const finalBarHeight = adjustedBarHeight; + const totalBarSpaceAdjusted = (finalBarHeight + barPadding) * dimensionCount; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算）（便于其他模板复制复用） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度 ---------- + + // 使用智能换行计算维度标签布局 + const targetFontSize = parseFloat(typography.label.font_size) || 14; + const maxLabelWidth_calc = 200; + const maxLabelHeight = finalBarHeight; + const lineSpacing = 1.2; + + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: maxLabelWidth_calc, + maxHeight: maxLabelHeight, + lineSpacing: lineSpacing, + targetFontSize: targetFontSize + }); + + const dimLabelConfig = dimLabelResult.dimLabelConfig; + const maxLabelWidth = dimLabelResult.maxLabelWidth; + + // 根据标签宽度调整边距 + margin.right = Math.max(margin.right, maxLabelWidth + 30); + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barScalePadding = variables.has_spacing ? 0.3 : 0.2; + + // 计算实际需要的总高度（基于调整后的条形高度） + const actualNeededHeight = (finalBarHeight + barPadding) * dimensionCount; + + // 确保Y轴比例尺使用基于finalBarHeight计算的适当范围 + // 如果actualNeededHeight小于innerHeight，则居中显示 + const yAxisStart = Math.max(0, (innerHeight - actualNeededHeight) / 2); + const yAxisEnd = Math.min(innerHeight, yAxisStart + actualNeededHeight); + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([yAxisStart, yAxisEnd]) + .padding(barScalePadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + // 绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barBandHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + const y = yScale(dimension); + const centerY = y + barBandHeight / 2; + + // 创建条形组 + const barGroup = g.append("g"); + + // 绘制矩形条形（没有圆角和边框） + barGroup.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidth) + .attr("height", barBandHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 准备图标尺寸 + const iconSize = barBandHeight * 0.7; + const iconX = 0; + const iconY = y + (barBandHeight - iconSize) / 2; + + // 添加图标（如果有）- 带白色圆形背景 + if (images.field && images.field[dimension]) { + // 添加白色圆形背景 + barGroup.append("circle") + .attr("cx", iconX + iconSize/2) + .attr("cy", iconY + iconSize/2) + .attr("r", iconSize/2) + .attr("fill", "white"); + + // 添加图标 + barGroup.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 格式化数值用于显示 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${barBandHeight * 0.6}px`; + + // 创建临时文本测量数值标签宽度（使用动态字体大小） + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: dynamicFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断数值标签是否能放入条形内 + const labelFitsInside = valueTextWidth + 10 < barWidth; + + // 添加数值标签（使用动态字体大小） + if (labelFitsInside) { + // 标签放在条形内部 + barGroup.append("text") + .attr("x", barWidth - 5) + .attr("y", y + barBandHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色 + .text(formattedValue); + } else { + // 标签放在条形外部 + barGroup.append("text") + .attr("x", barWidth + 5) + .attr("y", y + barBandHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用文本颜色 + .text(formattedValue); + } + + // 添加维度标签（X标签）- 放在条形右边，支持多行换行 + const labelConfig = dimLabelConfig[dimension]; + const labelX = barWidth + (labelFitsInside ? 5 : valueTextWidth + 15); + const labelGroup = barGroup.append("text") + .attr("x", labelX) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 在第一个条形上显示单位（如果有） + if (index === 0 && valueUnit) { + barGroup.append("text") + .attr("x", barWidth) + .attr("y", y - 5) // 条形顶部上方 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`(${valueUnit})`); + } + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..74d47e3ddcac348861c53b7d61b27f33f891e18b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_2_hand.js @@ -0,0 +1,234 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_2_hand", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })); + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([0, chartWidth]) + .nice(); + + const n_data = processedData.length + // 颜色比例尺 + const colorScale = (d, i) => { + if (i === n_data - 1) { + return colorResolver.variant(colorResolver.other("primary").value, { mode: "brighter", amount: 0.8 }); + } + return colorResolver.other("primary").value; + }; + + // 确定标签的最大长度： + let minYLabelRatio = 1.0 + const maxYLabelWidth = yScale.bandwidth() * 1.03 + + chartData.forEach(d => { + const yLabelText = String(d[xField]) + let currentWidth = chartUtils.text.measure(null, yLabelText).width + if (currentWidth > maxYLabelWidth) { + minYLabelRatio = Math.min(minYLabelRatio, maxYLabelWidth / currentWidth) + } + }) + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", "end") + .attr("dy", "0.32em") + .attr("x", -10) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("y", d => yScale(d.category)) + .attr("x", 0) + .attr("width", d => xScale(d.value)) + .attr("height", yScale.bandwidth()) + .attr("fill", (d, i) => colorScale(d, i)); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("x", d => xScale(d.value) + 5) + .attr("y", d => yScale(d.category) + yScale.bandwidth() / 2) + .attr("dy", "0.32em") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.number(d.value, { unit: yUnit, spaceBeforeUnit: true }).text) + .style("opacity", 1); // 直接设置为可见 + + const roughness = 1; + const bowing = 2; + const fillStyle = "hachure"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_3.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_3.js new file mode 100644 index 0000000000000000000000000000000000000000..fd90b7cf51c81c2fb8d8df7ffbfe25accd70ed63 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_3.js @@ -0,0 +1,224 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_3", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField] // 确保转换为数字 + })).sort((a, b) => b.value - a.value); // 按值降序排序 + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([0, chartWidth]) + .nice(); + + // 颜色比例尺 + const colorScale = d3.scaleLinear() + .domain([0, processedData.length - 1]) + .range([colorResolver.other("primary").value, d3.interpolateRgb(colorResolver.other("primary").value, "#ffffff")(0.6)]); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴（隐藏） + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("opacity", 0); // 隐藏X轴文本 + + // 添加Y轴（不显示刻度线） + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + + + + const yAxisGroup = chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + yAxisGroup.selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + let iconSize = yScale.bandwidth()*0.7 + let iconPadding = 10 + yAxisGroup.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + if(jsonData.images && jsonData.images.field[d]) { + tick.append("image") + .attr("x", - iconSize - iconPadding) // 10是原有的padding + .attr("y", -iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[d]); + tick.select("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("x", -iconSize-2*iconPadding) + } + }); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("rect") + .attr("class", "bar") + .attr("y", d => yScale(d.category)) + .attr("x", 0) + .attr("height", yScale.bandwidth()) + .attr("width", d => xScale(d.value)) // 直接设置最终宽度 + .attr("fill", (d, i) => colorScale(i)); + + // 添加数值标签 + const labels = chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("y", d => yScale(d.category) + yScale.bandwidth() / 2) + .attr("x", d => xScale(d.value) + 5) + .attr("dy", ".35em") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => chartUtils.format.autoText(d.value) + (yUnit ? ` ${yUnit}` : '')) + .style("opacity", 1); // 直接设置为可见 + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_30.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_30.js new file mode 100644 index 0000000000000000000000000000000000000000..1c4c4367e6940eea0121d4689221e07c25b2ed78 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_30.js @@ -0,0 +1,440 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_30", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "gradient", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + + // 提取维度字段 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + + // 获取数据维度数量 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const dimensionCount = dimensions.length; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 120, // 右侧足够显示标签 + bottom: 60, // 底部边距 + left: 100 // 左侧空间 + }; + + // 计算每个条形的理想高度 - 减小最小和最大高度 + const MIN_BAR_HEIGHT = 36; // 从64减小到45 + const MAX_BAR_HEIGHT = 72; // 从128减小到90 + const barPadding = variables.has_spacing ? 20 : 10; + + // 计算内部绘图区域尺寸（暂时宽度） + const innerWidth = width - margin.left - margin.right; + let innerHeight; // 高度稍后初始化 + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算最大值和最小值用于条形高度的缩放 + const maxValue = d3.max(chartData, d => +d[valueField]); + const minValue = d3.min(chartData, d => +d[valueField]); + + // ---------- 5. 计算标签宽度 ---------- + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整边距 + margin.right = Math.max(margin.right, maxLabelWidth + 30); + + // ---------- 6. 创建比例尺 ---------- + + // 固定条形间距 + const fixedBarSpacing = 15; // 条形之间的固定间距像素值 + + // 创建条形高度比例尺 - 根据数值大小来变化条形高度（1-2倍基础高度） + const barHeightScale = d3.scaleLinear() + .domain([minValue, maxValue]) + .range([1, 2]); // 1倍到2倍的倍数范围 + + // 基础条形高度 - 减小默认值 + const baseBarHeight = Math.min(MAX_BAR_HEIGHT, Math.max(MIN_BAR_HEIGHT, 50)); // 从60减小到50 + + // 计算每个条形的高度 + const barHeights = sortedDimensions.map(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + if (dataPoint) { + const heightScale = barHeightScale(+dataPoint[valueField]); + return baseBarHeight * heightScale; + } + return baseBarHeight; + }); + + // 计算总高度需求，包含固定间距 + const totalBarSpaceNeeded = barHeights.reduce((sum, height) => sum + height, 0) + + (barHeights.length - 1) * fixedBarSpacing; + + // 计算图表所需的最小高度 + const extraSpace = 150; // 为标题和底部空间预留的额外高度 + const minHeight = variables.min_height || 400; + const calculatedHeight = Math.max(minHeight, totalBarSpaceNeeded + extraSpace); + + // 使用计算值或用户指定值作为最终高度 + const height = variables.height || calculatedHeight; + + // 更新内部高度 + innerHeight = height - margin.top - margin.bottom; + + // X轴比例尺（用于数值）- 最小宽度从50改为100 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([75, innerWidth]); // 从100开始，而不是50 + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + // 计算所有条形中的最小高度，用于统一圆圈大小 + let minBarHeight = Math.min(...barHeights); + const uniformCircleRadius = minBarHeight * 0.3; + + // 计算每个条形的Y坐标，使用固定间距 + let barPositions = []; + let currentY = 0; + + barHeights.forEach(height => { + barPositions.push(currentY); + currentY += height + fixedBarSpacing; + }); + + // 居中调整所有条形 + const totalUsedHeight = currentY - fixedBarSpacing; // 减去最后一个不需要的间距 + const startY = (innerHeight - totalUsedHeight) / 2; + + // 绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 计算实际条形高度 + const barBandHeight = barHeights[index]; + + // 使用预先计算的Y位置，加上居中调整 + const y = startY + barPositions[index]; + + const barWidth = xScale(+dataPoint[valueField]); + const centerY = y + barBandHeight / 2; + + // 创建条形组 + const barGroup = g.append("g"); + + // 绘制矩形条形（没有圆角和边框） + barGroup.append("rect") + .attr("x", 0) + .attr("y", y) + .attr("width", barWidth) + .attr("height", barBandHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 准备图标尺寸 + const iconSize = barBandHeight * 0.7; + const iconX = 10; + const iconY = y + (barBandHeight - iconSize) / 2; + + // 添加图标（如果有）- 带白色圆形背景 + if (images.field && images.field[dimension]) { + // 添加白色圆形背景 + barGroup.append("circle") + .attr("cx", iconX + iconSize/2) + .attr("cy", iconY + iconSize/2) + .attr("r", iconSize/2) + .attr("fill", "white"); + + // 添加图标 + barGroup.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 格式化数值用于显示 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + // 减小字体大小（条形高度的比例） + const valueFontSize = `${barBandHeight * 0.35}px`; + const labelFontSize = `${barBandHeight * 0.22}px`; // 明显更小的x标签字体大小 + + // 创建临时文本测量数值标签宽度 + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断数值标签是否能放入条形内 + const labelFitsInside = valueTextWidth + 40 < barWidth; // 增加边距以容纳两行 + + // 添加标签 - 两行：数值和维度名称 + if (labelFitsInside) { + // 标签放在条形内部 + // 第一行：数值（上面一行） + barGroup.append("text") + .attr("x", barWidth - 15) + .attr("y", centerY - barBandHeight * 0.15) + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", valueFontSize) + .style("font-weight", "bold") + .style("fill", "#FFFFFF") // 白色 + .text(formattedValue); + + // 第二行：维度名称（下面一行）- 使用更小的字体 + barGroup.append("text") + .attr("x", barWidth - 15) + .attr("y", centerY + barBandHeight * 0.15) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", labelFontSize) + .style("font-weight", "normal") + .style("fill", "#FFFFFF") // 白色 + .text(dimension); + } else { + // 标签放在条形内左侧 + barGroup.append("text") + .attr("x", 15) + .attr("y", centerY) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", valueFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色 + .text(formattedValue); + } + + // 添加排名圆圈（黑色圆圈，白色文字）- 使用统一的半径 + const rankingCirclePadding = 5; // 圆圈与条形之间的间距 + const rankingCircleX = barWidth + rankingCirclePadding + uniformCircleRadius; + + // 绘制黑色圆圈 + barGroup.append("circle") + .attr("cx", rankingCircleX) + .attr("cy", centerY) + .attr("r", uniformCircleRadius) + .attr("fill", "#000000"); // 黑色填充 + + // 添加排名数字（白色） + barGroup.append("text") + .attr("x", rankingCircleX) + .attr("y", centerY) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "middle") // 水平居中 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${uniformCircleRadius * 1.2}px`) // 字体大小适合圆圈 + .style("font-weight", "bold") + .style("fill", "#FFFFFF") // 白色 + .text(index + 1); // 排名从1开始 + + // 在第一个条形上显示单位（如果有） + if (index === 0 && valueUnit) { + barGroup.append("text") + .attr("x", barWidth) + .attr("y", y - 5) // 条形顶部上方 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`(${valueUnit})`); + } + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_33.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_33.js new file mode 100644 index 0000000000000000000000000000000000000000..c2f8cd04e2a4fa5464d7566a7f2ea2d5c3513c5e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_33.js @@ -0,0 +1,603 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_33", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 600, + "background": "none", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js Horizontal Bar Chart plain chart#3 bar顶端三角 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 60, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值 + bottom: 30, // 底部边距 + left: 150 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 如果x维度数量超过15，每增加一个x，整个图像的高度增加3% + const baseHeight = variables.height || 600; + const adjustedHeight = dimensions.length > 15 + ? baseHeight * (1 + (dimensions.length - 15) * 0.03) + : baseHeight; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // 计算图标尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + // 智能换行：优先按单词；利用率不足50%时尝试塞字母；长词断行加"-"；断词后下一行单字母开头尽量回并 + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 计算标签宽度和布局 ---------- + + // 计算内部尺寸（先计算innerHeight，yScale依赖它） + const innerHeight = height - margin.top - margin.bottom; + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScale.bandwidth(); + const barGap = Math.max(0, yScale.step() - yScale.bandwidth()); + + // 图标尺寸配置 + const defaultFlagWidth = 48; + const defaultFlagHeight = 48; + const flagPadding = 0; + const textPadding = 5; + + // 计算动态图标尺寸 + const iconSize = calcIconSize(barHeight, { maxSize: 30, minRatio: 0.8, minPx: 10 }); + let flagWidth = iconSize.width; + let flagHeight = iconSize.height; + + // 构造带单位的标签列表 + const dimLabelsWithUnit = sortedDimensions.map(dimension => + dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}` + ); + + // 智能换行布局计算 + const dimLabelMaxWidth = width * 0.2; + const maxDimLabelHeight = barHeight + barGap; + const dimLabelLineSpacing = 1.01; + + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: dimLabelsWithUnit, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: maxDimLabelHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: Math.min(20, barHeight * 0.6) + }); + + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + const maxDimLabelWidth = dimLabelLayout.maxLabelWidth; + + // 计算最大数值标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + tempSvg.remove(); + + // 更新左边距（图标+标签宽度+间距） + const requiredLeftSpace = maxDimLabelWidth + textPadding + flagWidth + textPadding; + margin.left = requiredLeftSpace + 5; + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 7. 创建X轴比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 8. 添加标题和副标题 ---------- + + // 添加标题（如果有） + if (variables.title && variables.title.text) { + svg.append("text") + .attr("x", margin.left) + .attr("y", margin.top / 2) + .attr("text-anchor", "start") + .style("font-family", typography.title.font_family) + .style("font-size", typography.title.font_size) + .style("font-weight", typography.title.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(variables.title.text); + } + + // 添加副标题（如果有） + if (variables.subtitle && variables.subtitle.text) { + svg.append("text") + .attr("x", margin.left) + .attr("y", margin.top / 2 + 20) + .attr("text-anchor", "start") + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(variables.subtitle.text); + } + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 添加交替行背景（如果需要） + if (jsonData.variation?.background === "styled") { + sortedDimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制带三角形尾部的条形 + if (barWidth > 0) { // 仅当宽度大于0时绘制 + // 三角形的宽度，设置为条形图高度，但最小10px，最大30px + const triangleWidth = Math.min(30, Math.max(10, barHeight)); + // 确保三角形宽度不超过总宽度 + const actualTriangleWidth = Math.min(triangleWidth, barWidth); + // 矩形部分的宽度 + const rectWidth = barWidth - actualTriangleWidth; + + g.append("path") + .attr("d", () => { + const yPos = yScale(dimension); + // 构建路径 + // 从左上角开始 + let path = `M 0 ${yPos}`; + // 到矩形右上角 + path += ` L ${rectWidth} ${yPos}`; + // 到三角形上顶点 + path += ` L ${rectWidth} ${yPos}`; + // 到三角形右侧顶点 (尖端) + path += ` L ${barWidth} ${yPos + barHeight / 2}`; + // 到三角形下顶点 + path += ` L ${rectWidth} ${yPos + barHeight}`; + // 到矩形右下角 + path += ` L ${rectWidth} ${yPos + barHeight}`; + // 到左下角 + path += ` L 0 ${yPos + barHeight}`; + // 闭合路径 + path += ` Z`; + return path; + }) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + } + + // 添加带图标的维度标签 + const flagX = -flagWidth - flagPadding - 5; + const labelY = yScale(dimension) + barHeight / 2; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", labelY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签 + g.append("text") + .attr("x", flagX - 5) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4.js new file mode 100644 index 0000000000000000000000000000000000000000..fea3807cb166a763764a7a1080e7300dc71bb17a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4.js @@ -0,0 +1,525 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_4", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 60, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值 + bottom: 30, // 底部边距 + left: 150 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 布局设置 ---------- + + // 图标尺寸 + const flagWidth = 20; + const flagHeight = 15; + const flagPadding = 0; + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 8. 计算维度标签布局（智能换行）---------- + + const barHeight = yScale.bandwidth(); + const barGap = Math.max(0, yScale.step() - yScale.bandwidth()); + const maxDimLabelHeight = barHeight + barGap; + + const dimLabelLayout = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: Math.max(100, margin.left - flagWidth - 20), + maxHeight: maxDimLabelHeight * 0.8, + lineSpacing: 1.01, + targetFontSize: Math.min(20, barHeight * 0.6) + }); + const dimLabelConfig = dimLabelLayout.dimLabelConfig; + + // 根据实际标签宽度调整左边距 + margin.left = Math.max(margin.left, dimLabelLayout.maxLabelWidth + flagWidth + 30); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 添加交替行背景（如果需要） + if (jsonData.variation?.background === "styled") { + sortedDimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 添加带图标的维度标签 + const flagX = -flagWidth - flagPadding - 5; + const labelY = yScale(dimension) + barHeight / 2; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", labelY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签（支持多行智能换行） + const labelConfig = dimLabelConfig[dimension]; + const textElem = g.append("text") + .attr("x", flagX - 5) + .attr("y", labelY) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = labelY - (labelConfig.lines.length - 1) * lineHeight / 2; + textElem.attr("y", startY); + labelConfig.lines.forEach((line, i) => { + textElem.append("tspan") + .attr("x", flagX - 5) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}px`) + .text(line); + }); + } else { + textElem.attr("dy", "0.35em") + .text(labelConfig.lines[0] || dimension); + } + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..28572c776b5ab67b381517a7c99df7ae62ad4a3d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_4_hand.js @@ -0,0 +1,584 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_4_hand", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 60, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值 + bottom: 30, // 底部边距 + left: 150 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 布局计算和字体调整 ---------- + + const textPadding = 5; + const maxIconSize = 30; + const dimLabelMaxWidth = width * 0.25; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + const textIconGap = 5; + const flagBarGap = 10; + const barValueGap = 10; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + // Y轴比例尺（用于维度） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const rowHeight = yScale.bandwidth(); + + // icon尺寸（按rowHeight动态） + const iconSize = calcIconSize(rowHeight, { maxSize: maxIconSize, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: rowHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算最大数值标签宽度（用于右边距） + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + tempSvg.remove(); + + // 根据标签宽度调整左边距 + margin.left = maxLabelWidth + textIconGap + flagWidth + flagBarGap; + + // 调整右边距以适应数值标签 + margin.right = Math.max(margin.right, maxValueWidth + barValueGap); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#882e2e" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + } + + // ---------- 7. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取条形颜色的辅助函数 + // 获取条形颜色的辅助函数 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#882e2e" }).value; // 默认暗红色 + }; + + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 添加交替行背景（如果需要） + if (jsonData.variation?.background === "styled") { + sortedDimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + const centerY = yScale(dimension) + barHeight / 2; + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 计算文本X位置和图标位置 + const textX = -textIconGap - flagWidth - textIconGap; + const flagX = -flagWidth - textIconGap; + + // 添加维度文本标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", textX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", textX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + g.append("text") + .attr("x", barWidth + barValueGap) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + const roughness = 1; + const bowing = 2; + const fillStyle = "hachure"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5.js new file mode 100644 index 0000000000000000000000000000000000000000..1f9dc639b577ae62ec9d656542c2341fb1985f2c --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5.js @@ -0,0 +1,384 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_5", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js (样式02) +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#0099ff" } // 默认使用蓝色作为条形颜色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const originalHeight = variables.height || 600; + + // 设置边距 - 这个样式需要更多的上部和下部空间用于标签 + const margin = { + top: 100, // 顶部边距 + right: 80, // 右侧足够显示数值标签 + bottom: 70, // 底部边距 + left: 20 // 左侧边距 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据（与图片相符） + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 计算标签宽度、动态高度和图表尺寸 ---------- + + // 动态调整高度 + const numDimensions = sortedDimensions.length; + let adjustedHeight = originalHeight; + const maxHeightFactor = 1.88; + + if (numDimensions > 18) { + // 根据条目数量比例计算建议高度 + const suggestedHeight = originalHeight * (numDimensions / 18); + // 限制最大高度 + adjustedHeight = Math.min(suggestedHeight, originalHeight * maxHeightFactor); + } + + // 使用调整后的高度 + const height = adjustedHeight; + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整右边距 + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用调整后的高度 + .attr("viewBox", `0 0 ${width} ${height}`) // 使用调整后的高度 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#0099ff" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(primaryColor)); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.7 : 0.6 ; + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 4. 在"正式渲染"前，测量合适的维度标签字体大小 ---------- + + // 4.1 从 typography.label.font_size 中解析初始字号（可能是 "12px" 这种写法） + const defaultFontSizeStr = typography.label.font_size || "12px"; + let fontSize = parseFloat(defaultFontSizeStr); + + // 设置最小字号，避免太小看不清 + const minFontSize = 4; // 保证最小字体是 4 + + // 4.2 定义一个函数，用给定的字号去测量"所有"维度文本的最大高度 + function getMaxTextHeightForFontSize(testFontSize) { + let maxH = 0; + sortedDimensions.forEach(dim => { + const textSize = chartUtils.text.measure(null, dim, { + fontFamily: typography.label.font_family, + fontSize: testFontSize, + fontWeight: typography.label.font_weight, + }); + maxH = Math.max(maxH, textSize.height); + }); + return maxH; + } + + // 4.3 计算两条 bar（在 yScale 排列）之间的距离：就是 yScale.step() + const barStep = yScale.step(); + // 因为标签要画在 bar 底部 + 一定空隙（例如 +10 px）， + // 相邻两条 bar 的文字基线相差 barStep。若文字高度大于 barStep，就会挤到下一行文本 + // 简单判断：若 textHeight > barStep，则判定会重叠 + + // 4.4 不断减小字号直到能放下或到达最小字号 + while (true) { + if (fontSize < minFontSize) { + fontSize = minFontSize; + break; + } + const maxTextHeight = getMaxTextHeightForFontSize(fontSize); + if (maxTextHeight <= barStep) { + // 说明可以放下，不会重叠 + break; + } + fontSize--; + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#0099ff" }).value; // 默认蓝色 + }; + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.variant(getBarColor(), { mode: "darker", amount: 0.2 }); + }; + + // ---- 动态计算维度标签位置 ---- + // 计算两个条形图之间的距离 + const barGap = yScale.step() - yScale.bandwidth(); + + // 设置一个安全的最小距离，确保标签与条形图不会重叠 + const minSafeLabelDistance = Math.max(3, barGap / 4); + + // 调整字体大小计算部分，让它更合理地配合条形间距 + function calculateOptimalFontSize() { + // 计算条形之间的可用空间 (即下方空间) + const availableSpaceBelow = yScale.step() - yScale.bandwidth(); + + // 基于可用空间估算理想字体大小 + // 字体高度约等于字体大小，留一点点空隙 (e.g., 2px) + const fontSizeEstimate = Math.floor(availableSpaceBelow - 2); + + // 限制在合理范围内，确保不小于 minFontSize + return Math.max(minFontSize, Math.min(fontSize, fontSizeEstimate)); + } + + // 调整现有的fontSize计算 + fontSize = calculateOptimalFontSize(); + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 创建条形组 + const barGroup = g.append("g") + .attr("transform", `translate(0, ${yScale(dimension)})`); + + // 绘制条形 + barGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 计算标签位置 - 放置在条形下方，避免重叠 + const labelYPosition = barHeight + minSafeLabelDistance; // 在条形下方留出安全距离 + + // 添加维度标签 + barGroup.append("text") + .attr("x", 0) // 标签从条形左侧开始 + .attr("y", labelYPosition) + .attr("dy", "0.71em") // 调整基线使文本顶部接近labelYPosition + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.label.font_family) + .style("font-size", fontSize + "px") + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 添加数值标签（在条形右侧） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + barGroup.append("text") + .attr("x", barWidth + 5) // 条形右侧10px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..06bd808baa9e431d6e8edabcda86575300c3acaf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_5_hand.js @@ -0,0 +1,407 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_5_hand", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js (样式02) +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#0099ff" } // 默认使用蓝色作为条形颜色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值单位规范 + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = 1; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const originalHeight = variables.height || 600; + + // 设置边距 - 这个样式需要更多的上部和下部空间用于标签 + const margin = { + top: 100, // 顶部边距 + right: 80, // 右侧足够显示数值标签 + bottom: 70, // 底部边距 + left: 20 // 左侧边距 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据（与图片相符） + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 计算标签宽度、动态高度和图表尺寸 ---------- + + // 动态调整高度 + const numDimensions = sortedDimensions.length; + let adjustedHeight = originalHeight; + const maxHeightFactor = 1.88; + + if (numDimensions > 18) { + // 根据条目数量比例计算建议高度 + const suggestedHeight = originalHeight * (numDimensions / 18); + // 限制最大高度 + adjustedHeight = Math.min(suggestedHeight, originalHeight * maxHeightFactor); + } + + // 使用调整后的高度 + const height = adjustedHeight; + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整右边距 + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用调整后的高度 + .attr("viewBox", `0 0 ${width} ${height}`) // 使用调整后的高度 + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + const primaryColor = colorResolver.other("primary", { fallback: "#0099ff" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(primaryColor)); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.7 : 0.6 ; + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 4. 在"正式渲染"前，测量合适的维度标签字体大小 ---------- + + // 4.1 从 typography.label.font_size 中解析初始字号（可能是 "12px" 这种写法） + const defaultFontSizeStr = typography.label.font_size || "12px"; + let fontSize = parseFloat(defaultFontSizeStr); + + // 设置最小字号，避免太小看不清 + const minFontSize = 4; // 保证最小字体是 4 + + // 4.2 定义一个函数，用给定的字号去测量"所有"维度文本的最大高度 + function getMaxTextHeightForFontSize(testFontSize) { + let maxH = 0; + sortedDimensions.forEach(dim => { + const textSize = chartUtils.text.measure(null, dim, { + fontFamily: typography.label.font_family, + fontSize: testFontSize, + fontWeight: typography.label.font_weight, + }); + maxH = Math.max(maxH, textSize.height); + }); + return maxH; + } + + // 4.3 计算两条 bar（在 yScale 排列）之间的距离：就是 yScale.step() + const barStep = yScale.step(); + // 因为标签要画在 bar 底部 + 一定空隙（例如 +10 px）， + // 相邻两条 bar 的文字基线相差 barStep。若文字高度大于 barStep，就会挤到下一行文本 + // 简单判断：若 textHeight > barStep，则判定会重叠 + + // 4.4 不断减小字号直到能放下或到达最小字号 + while (true) { + if (fontSize < minFontSize) { + fontSize = minFontSize; + break; + } + const maxTextHeight = getMaxTextHeightForFontSize(fontSize); + if (maxTextHeight <= barStep) { + // 说明可以放下，不会重叠 + break; + } + fontSize--; + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制条形和标签 ---------- + + // 获取条形颜色 + const getBarColor = () => { + return colorResolver.other("primary", { fallback: "#0099ff" }).value; // 默认蓝色 + }; + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.variant(getBarColor(), { mode: "darker", amount: 0.2 }); + }; + + // ---- 动态计算维度标签位置 ---- + // 计算两个条形图之间的距离 + const barGap = yScale.step() - yScale.bandwidth(); + + // 设置一个安全的最小距离，确保标签与条形图不会重叠 + const minSafeLabelDistance = Math.max(3, barGap / 4); + + // 调整字体大小计算部分，让它更合理地配合条形间距 + function calculateOptimalFontSize() { + // 计算条形之间的可用空间 (即下方空间) + const availableSpaceBelow = yScale.step() - yScale.bandwidth(); + + // 基于可用空间估算理想字体大小 + // 字体高度约等于字体大小，留一点点空隙 (e.g., 2px) + const fontSizeEstimate = Math.floor(availableSpaceBelow - 2); + + // 限制在合理范围内，确保不小于 minFontSize + return Math.max(minFontSize, Math.min(fontSize, fontSizeEstimate)); + } + + // 调整现有的fontSize计算 + fontSize = calculateOptimalFontSize(); + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 创建条形组 + const barGroup = g.append("g") + .attr("transform", `translate(0, ${yScale(dimension)})`); + + // 绘制条形 + barGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? "url(#bar-gradient)" : getBarColor()) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 计算标签位置 - 放置在条形下方，避免重叠 + const labelYPosition = barHeight + minSafeLabelDistance; // 在条形下方留出安全距离 + + // 添加维度标签 + barGroup.append("text") + .attr("x", 0) // 标签从条形左侧开始 + .attr("y", labelYPosition) + .attr("dy", "0.71em") // 调整基线使文本顶部接近labelYPosition + .attr("text-anchor", "start") // 左对齐 + .style("font-family", typography.label.font_family) + .style("font-size", fontSize + "px") + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 添加数值标签（在条形右侧） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + barGroup.append("text") + .attr("x", barWidth + 5) // 条形右侧10px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + const roughness = 1; + const bowing = 2; + const fillStyle = "hachure"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_6.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_6.js new file mode 100644 index 0000000000000000000000000000000000000000..e81e4e5da668939bc346c04d77cf0e193c2e88cd --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_6.js @@ -0,0 +1,605 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_6", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = true; // 默认启用圆角，匹配图片中的样式 + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置初始边距，稍后会根据文本宽度调整 + const margin = { + top: 60, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值标签 + bottom: 30, // 底部边距 + left: 20 // 初始左侧边距，将在计算文本宽度后调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 根据条形高度计算icon尺寸（便于其他模板复制复用） + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算）（便于其他模板复制复用） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 5. 布局计算和字体调整 ---------- + + const textPadding = 5; + const maxIconSize = 30; + const barPadding = variables.has_spacing ? 0.3 : 0.2; + const dimLabelMaxWidth = width * 0.25; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + const textIconGap = 5; + const flagBarGap = 10; + const barValueGap = 10; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const rowHeight = yScale.bandwidth(); + + // icon尺寸（按rowHeight动态） + const iconSize = calcIconSize(rowHeight, { maxSize: maxIconSize, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: rowHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算最大数值标签宽度（用于右边距） + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + tempSvg.remove(); + + // 根据标签宽度调整左边距 + margin.left = maxLabelWidth + textIconGap + flagWidth + flagBarGap; + + // 调整右边距以适应数值标签 + margin.right = Math.max(margin.right, maxValueWidth + barValueGap); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加中心渐变（两边暗，中间亮）- 强制为所有bar应用 + const primaryColor = colorResolver.other("primary", { fallback: "#C0985A" }).value; // 金褐色作为默认值 + + const gradient = defs.append("linearGradient") + .attr("id", "bar-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + // 定义从左到右的渐变，中间最亮，两边较暗 + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 2.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.3 })); + + // ---------- 7. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 计算元素位置 ---------- + + // 图标的起始 X 位置 (在条形图左侧) + const flagX = -flagBarGap - flagWidth; + + // 文本标签的 X 位置 (右对齐，右边缘与图标保持小间距) + const textX = flagX - textIconGap; // 文本右对齐，X位置设为图标左边缘减去小间距 + + // 条形图的起始 X 位置 (在图标右侧，此处为坐标系原点) + const barX = 0; + + // ---------- 10. 绘制条形和标签 ---------- + + // 设置主色，用于生成渐变和描边 + const getPrimaryColor = () => { + // 根据用户提供的图片，使用金褐色作为默认值 + return colorResolver.other("primary", { fallback: "#C0985A" }).value; + }; + + // 获取描边颜色（使用主色的更暗版本） + const getStrokeColor = () => { + const primaryColor = getPrimaryColor(); + // 使用比填充色更暗的颜色作为描边 + return colorResolver.variant(primaryColor, { mode: "darker", amount: 0.4 }); + }; + + // 添加交替行背景 + if (jsonData.variation?.background === "styled" || true) { // 默认启用交替行背景 + sortedDimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left + margin.right) + .attr("height", yScale.bandwidth()) + .attr("class", "background") + .attr("fill", "#f5f5f5") + .attr("opacity", 1); + } + }); + } + + // 添加四角星函数 - 用于第一个条形图 + function addStarsToFirstBar(g, dimension, barWidth, barHeight, centerY) { + // 只为第一个维度添加星星（排序后的第一个维度即销量最高的） + if (dimension === sortedDimensions[0]) { + // 星星尺寸 + const starWidth = 40; + const starHeight = 40; + + // 星星位置 - 基于条形图末端 + const xPos = barWidth*0.8; // 条形图末端位置 + + // 星星的base64编码 - 替换为您的实际base64编码 + // 这里使用示例base64编码，您需要替换为自己的四角星图片 + const starBase64 = "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="1024px" height="1024px" style="shape-rendering:geometricPrecision; text-rendering:geometricPrecision; image-rendering:optimizeQuality; fill-rule:evenodd; clip-rule:evenodd" xmlns:xlink="http://www.w3.org/1999/xlink">
<g><path style="opacity:0.004" fill="#6e6959" d="M 659.5,13.5 C 661.337,13.6395 661.67,14.3061 660.5,15.5C 659.702,15.0431 659.369,14.3764 659.5,13.5 Z"/></g>
<g><path style="opacity:0.008" fill="#b8a167" d="M 503.5,121.5 C 505.337,121.639 505.67,122.306 504.5,123.5C 503.702,123.043 503.369,122.376 503.5,121.5 Z"/></g>
<g><path style="opacity:0.859" fill="#d2b57e" d="M 507.5,124.5 C 507.624,130.069 506.957,135.402 505.5,140.5C 505.376,134.931 506.043,129.598 507.5,124.5 Z"/></g>
<g><path style="opacity:0.447" fill="#d2b985" d="M 513.5,125.5 C 514.946,131.274 515.612,137.274 515.5,143.5C 514.19,137.712 513.523,131.712 513.5,125.5 Z"/></g>
<g><path style="opacity:0.988" fill="#c89e46" d="M 504.5,158.5 C 504.966,152.509 505.299,146.509 505.5,140.5C 506.957,135.402 507.624,130.069 507.5,124.5C 508.268,123.737 508.768,122.737 509,121.5C 508.535,130.654 507.702,139.821 506.5,149C 506.544,150.764 506.878,152.431 507.5,154C 506.312,156.087 505.312,157.587 504.5,158.5 Z"/></g>
<g><path style="opacity:0.992" fill="#d1b066" d="M 513.5,124.5 C 512.732,123.737 512.232,122.737 512,121.5C 512.916,135.836 514.249,150.169 516,164.5C 516.494,162.866 516.66,161.199 516.5,159.5C 516.833,159.5 517.167,159.5 517.5,159.5C 518.324,162.764 518.658,166.098 518.5,169.5C 517.778,169.082 517.278,168.416 517,167.5C 516.667,168.833 516.333,170.167 516,171.5C 514.951,169.893 513.451,169.227 511.5,169.5C 511.813,172.247 511.48,174.914 510.5,177.5C 509.833,176.167 509.167,174.833 508.5,173.5C 507.476,174.853 506.143,175.52 504.5,175.5C 504.666,171.486 504.499,167.486 504,163.5C 503.505,165.473 503.338,167.473 503.5,169.5C 502.38,165.983 502.38,162.316 503.5,158.5C 503.833,158.5 504.167,158.5 504.5,158.5C 505.312,157.587 506.312,156.087 507.5,154C 506.878,152.431 506.544,150.764 506.5,149C 507.702,139.821 508.535,130.654 509,121.5C 508.768,122.737 508.268,123.737 507.5,124.5C 509.5,112.5 511.5,112.5 513.5,124.5 Z"/></g>
<g><path style="opacity:0.984" fill="#c79e48" d="M 513.5,124.5 C 513.5,124.833 513.5,125.167 513.5,125.5C 513.523,131.712 514.19,137.712 515.5,143.5C 515.569,148.854 515.902,154.187 516.5,159.5C 516.66,161.199 516.494,162.866 516,164.5C 514.249,150.169 512.916,135.836 512,121.5C 512.232,122.737 512.732,123.737 513.5,124.5 Z"/></g>
<g><path style="opacity:0.2" fill="#dac293" d="M 505.5,140.5 C 505.299,146.509 504.966,152.509 504.5,158.5C 504.167,158.5 503.833,158.5 503.5,158.5C 503.523,152.288 504.19,146.288 505.5,140.5 Z"/></g>
<g><path style="opacity:0.239" fill="#d5bd89" d="M 515.5,143.5 C 516.806,148.616 517.473,153.949 517.5,159.5C 517.167,159.5 516.833,159.5 516.5,159.5C 515.902,154.187 515.569,148.854 515.5,143.5 Z"/></g>
<g><path style="opacity:0.012" fill="#c9ac68" d="M 499.5,163.5 C 501.337,163.639 501.67,164.306 500.5,165.5C 499.702,165.043 499.369,164.376 499.5,163.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c8ac66" d="M 499.5,167.5 C 501.337,167.639 501.67,168.306 500.5,169.5C 499.702,169.043 499.369,168.376 499.5,167.5 Z"/></g>
<g><path style="opacity:0.995" fill="#d6b368" d="M 518.5,169.5 C 519.477,172.287 519.81,175.287 519.5,178.5C 519.5,180.167 519.5,181.833 519.5,183.5C 518.566,184.568 518.232,185.901 518.5,187.5C 517.221,188.968 515.554,189.635 513.5,189.5C 513.5,190.833 513.5,192.167 513.5,193.5C 512.167,193.5 510.833,193.5 509.5,193.5C 509.714,197.257 508.714,197.924 506.5,195.5C 505.833,196.833 505.167,198.167 504.5,199.5C 503.943,197.668 502.943,196.335 501.5,195.5C 503.231,189.228 503.231,186.561 501.5,187.5C 500.844,186.378 500.511,185.045 500.5,183.5C 500.634,178.508 501.634,173.842 503.5,169.5C 503.338,167.473 503.505,165.473 504,163.5C 504.499,167.486 504.666,171.486 504.5,175.5C 506.143,175.52 507.476,174.853 508.5,173.5C 509.167,174.833 509.833,176.167 510.5,177.5C 511.48,174.914 511.813,172.247 511.5,169.5C 513.451,169.227 514.951,169.893 516,171.5C 516.333,170.167 516.667,168.833 517,167.5C 517.278,168.416 517.778,169.082 518.5,169.5 Z"/></g>
<g><path style="opacity:0.91" fill="#dcc393" d="M 519.5,178.5 C 520.737,183.96 521.404,189.627 521.5,195.5C 520.205,191.733 519.539,187.733 519.5,183.5C 519.5,181.833 519.5,180.167 519.5,178.5 Z"/></g>
<g><path style="opacity:0.984" fill="#d4ae5b" d="M 501.5,195.5 C 501.376,202.993 500.376,208.993 498.5,213.5C 498.998,208.848 499.331,204.181 499.5,199.5C 499.151,195.258 499.817,191.258 501.5,187.5C 503.231,186.561 503.231,189.228 501.5,195.5 Z"/></g>
<g><path style="opacity:0.995" fill="#d9b86c" d="M 518.5,187.5 C 519.889,199.505 521.389,211.505 523,223.5C 523.498,220.518 523.665,217.518 523.5,214.5C 524.477,217.287 524.81,220.287 524.5,223.5C 524.532,230.448 525.532,237.114 527.5,243.5C 528.44,247.259 528.773,250.926 528.5,254.5C 528.423,258.215 528.756,261.881 529.5,265.5C 529.5,265.833 529.5,266.167 529.5,266.5C 527.818,262.297 526.651,256.63 526,249.5C 523.589,246.895 521.089,246.895 518.5,249.5C 517.266,247.602 517.599,245.935 519.5,244.5C 517.995,243.158 517.328,241.492 517.5,239.5C 515.508,239.328 513.842,239.995 512.5,241.5C 510.365,240.119 508.032,239.119 505.5,238.5C 506.167,237.833 506.833,237.167 507.5,236.5C 503.893,235.511 500.226,235.177 496.5,235.5C 496.656,239.582 496.156,243.582 495,247.5C 494.505,245.527 494.338,243.527 494.5,241.5C 494.89,232.319 495.89,222.986 497.5,213.5C 497.833,213.5 498.167,213.5 498.5,213.5C 500.376,208.993 501.376,202.993 501.5,195.5C 502.943,196.335 503.943,197.668 504.5,199.5C 505.167,198.167 505.833,196.833 506.5,195.5C 508.714,197.924 509.714,197.257 509.5,193.5C 510.833,193.5 512.167,193.5 513.5,193.5C 513.5,192.167 513.5,190.833 513.5,189.5C 515.554,189.635 517.221,188.968 518.5,187.5 Z"/></g>
<g><path style="opacity:0.937" fill="#dbbf84" d="M 521.5,197.5 C 522.89,200.094 523.223,202.761 522.5,205.5C 521.527,203.052 521.194,200.385 521.5,197.5 Z"/></g>
<g><path style="opacity:0.969" fill="#d4af5a" d="M 519.5,183.5 C 519.539,187.733 520.205,191.733 521.5,195.5C 521.5,196.167 521.5,196.833 521.5,197.5C 521.194,200.385 521.527,203.052 522.5,205.5C 523.477,208.287 523.81,211.287 523.5,214.5C 523.665,217.518 523.498,220.518 523,223.5C 521.389,211.505 519.889,199.505 518.5,187.5C 518.232,185.901 518.566,184.568 519.5,183.5 Z"/></g>
<g><path style="opacity:0.308" fill="#dcc28c" d="M 499.5,199.5 C 499.331,204.181 498.998,208.848 498.5,213.5C 498.167,213.5 497.833,213.5 497.5,213.5C 497.279,212.265 496.612,211.265 495.5,210.5C 497.566,207.007 498.9,203.341 499.5,199.5 Z"/></g>
<g><path style="opacity:0.122" fill="#dfc58f" d="M 524.5,223.5 C 526.042,229.953 527.042,236.62 527.5,243.5C 525.532,237.114 524.532,230.448 524.5,223.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d5b86e" d="M 491.5,237.5 C 493.337,237.639 493.67,238.306 492.5,239.5C 491.702,239.043 491.369,238.376 491.5,237.5 Z"/></g>
<g><path style="opacity:0.996" fill="#debe72" d="M 529.5,266.5 C 531.265,269.123 531.932,272.123 531.5,275.5C 532.234,276.878 532.901,278.378 533.5,280C 533.043,280.414 532.709,280.914 532.5,281.5C 533.757,287.452 534.757,293.452 535.5,299.5C 535.724,303.179 536.058,306.846 536.5,310.5C 534.893,309.145 534.226,306.811 534.5,303.5C 532.167,303.5 529.833,303.5 527.5,303.5C 527.714,299.743 526.714,299.076 524.5,301.5C 523.953,297.842 522.286,294.842 519.5,292.5C 521.924,290.286 521.257,289.286 517.5,289.5C 517.5,287.5 517.5,285.5 517.5,283.5C 512.154,283.131 510.82,280.798 513.5,276.5C 512.311,275.571 510.978,275.238 509.5,275.5C 509.714,271.743 508.714,271.076 506.5,273.5C 504.437,267.421 500.771,262.421 495.5,258.5C 497.534,256.401 497.868,254.068 496.5,251.5C 495.818,252.243 495.151,252.909 494.5,253.5C 494.631,252.761 494.464,252.094 494,251.5C 493.79,253.058 493.29,254.391 492.5,255.5C 492.062,255.565 491.728,255.399 491.5,255C 492.706,250.442 493.706,245.942 494.5,241.5C 494.338,243.527 494.505,245.527 495,247.5C 496.156,243.582 496.656,239.582 496.5,235.5C 500.226,235.177 503.893,235.511 507.5,236.5C 506.833,237.167 506.167,237.833 505.5,238.5C 508.032,239.119 510.365,240.119 512.5,241.5C 513.842,239.995 515.508,239.328 517.5,239.5C 517.328,241.492 517.995,243.158 519.5,244.5C 517.599,245.935 517.266,247.602 518.5,249.5C 521.089,246.895 523.589,246.895 526,249.5C 526.651,256.63 527.818,262.297 529.5,266.5 Z"/></g>
<g><path style="opacity:0.971" fill="#dbb65b" d="M 494.5,253.5 C 493.828,261.544 492.828,269.544 491.5,277.5C 490.774,273.679 490.774,269.679 491.5,265.5C 491.5,264.833 491.5,264.167 491.5,263.5C 492.468,261.393 492.802,259.059 492.5,256.5C 492.5,256.167 492.5,255.833 492.5,255.5C 493.29,254.391 493.79,253.058 494,251.5C 494.464,252.094 494.631,252.761 494.5,253.5 Z"/></g>
<g><path style="opacity:0.651" fill="#e2c993" d="M 492.5,256.5 C 492.802,259.059 492.468,261.393 491.5,263.5C 491.279,262.265 490.612,261.265 489.5,260.5C 490.694,259.201 491.694,257.868 492.5,256.5 Z"/></g>
<g><path style="opacity:0.996" fill="#e3c479" d="M 536.5,310.5 C 536.833,310.5 537.167,310.5 537.5,310.5C 538.728,312.01 538.728,313.51 537.5,315C 539.201,317.765 540.534,320.765 541.5,324C 542.037,332.148 544.037,340.148 547.5,348C 547.034,349.299 547.034,350.799 547.5,352.5C 547.263,353.791 547.596,354.791 548.5,355.5C 554.945,375.387 563.779,394.054 575,411.5C 579.367,417.57 584.2,423.236 589.5,428.5C 589.414,429.496 589.748,430.329 590.5,431C 587.123,431.25 584.457,432.75 582.5,435.5C 580.167,433.167 577.833,430.833 575.5,428.5C 576.167,427.833 576.833,427.167 577.5,426.5C 575.5,425.833 573.5,425.167 571.5,424.5C 572.167,423.833 572.833,423.167 573.5,422.5C 571.5,421.833 569.5,421.167 567.5,420.5C 570.167,419.167 570.167,417.833 567.5,416.5C 569.844,415.663 571.844,414.329 573.5,412.5C 568.942,411.554 564.942,409.554 561.5,406.5C 562.167,405.833 562.833,405.167 563.5,404.5C 560.833,403.833 558.167,403.167 555.5,402.5C 557.26,399.788 557.927,396.788 557.5,393.5C 556.167,393.5 554.833,393.5 553.5,393.5C 553.5,392.167 553.5,390.833 553.5,389.5C 548.306,389.058 548.306,388.058 553.5,386.5C 551.558,383.537 548.892,381.871 545.5,381.5C 545.021,377.566 545.688,373.899 547.5,370.5C 546.248,368.999 545.248,367.332 544.5,365.5C 543.167,368.167 541.833,368.167 540.5,365.5C 539.087,362.339 537.42,359.339 535.5,356.5C 537.807,354.672 537.474,353.006 534.5,351.5C 533.921,348.412 532.587,345.745 530.5,343.5C 529.41,335.724 526.41,328.724 521.5,322.5C 522.167,321.833 522.833,321.167 523.5,320.5C 518.732,315.742 515.732,310.075 514.5,303.5C 513.833,302.833 513.167,302.167 512.5,301.5C 511.158,303.005 509.492,303.672 507.5,303.5C 507.328,301.508 507.995,299.842 509.5,298.5C 507.995,297.158 507.328,295.492 507.5,293.5C 505.508,293.328 503.842,293.995 502.5,295.5C 501.876,289.882 498.876,286.548 493.5,285.5C 494.036,282.302 493.369,279.635 491.5,277.5C 492.828,269.544 493.828,261.544 494.5,253.5C 495.151,252.909 495.818,252.243 496.5,251.5C 497.868,254.068 497.534,256.401 495.5,258.5C 500.771,262.421 504.437,267.421 506.5,273.5C 508.714,271.076 509.714,271.743 509.5,275.5C 510.978,275.238 512.311,275.571 513.5,276.5C 510.82,280.798 512.154,283.131 517.5,283.5C 517.5,285.5 517.5,287.5 517.5,289.5C 521.257,289.286 521.924,290.286 519.5,292.5C 522.286,294.842 523.953,297.842 524.5,301.5C 526.714,299.076 527.714,299.743 527.5,303.5C 529.833,303.5 532.167,303.5 534.5,303.5C 534.226,306.811 534.893,309.145 536.5,310.5 Z"/></g>
<g><path style="opacity:0.98" fill="#ddc082" d="M 528.5,254.5 C 529.343,257.326 530.009,260.326 530.5,263.5C 530.457,264.416 530.124,265.083 529.5,265.5C 528.756,261.881 528.423,258.215 528.5,254.5 Z"/></g>
<g><path style="opacity:0.984" fill="#d8b153" d="M 531.5,275.5 C 531.664,278.187 531.497,280.854 531,283.5C 529.838,278.875 529.504,274.208 530,269.5C 530.191,271.708 530.691,273.708 531.5,275.5 Z"/></g>
<g><path style="opacity:0.984" fill="#e2c172" d="M 487.5,299.5 C 486.369,300.202 486.036,298.868 486.5,295.5C 486.229,293.068 486.562,290.401 487.5,287.5C 488.384,284.977 489.218,282.31 490,279.5C 490.152,286.281 489.319,292.947 487.5,299.5 Z"/></g>
<g><path style="opacity:0.008" fill="#e1c684" d="M 479.5,305.5 C 481.337,305.639 481.67,306.306 480.5,307.5C 479.702,307.043 479.369,306.376 479.5,305.5 Z"/></g>
<g><path style="opacity:0.086" fill="#e7cea1" d="M 535.5,299.5 C 536.903,302.909 537.57,306.575 537.5,310.5C 537.167,310.5 536.833,310.5 536.5,310.5C 536.058,306.846 535.724,303.179 535.5,299.5 Z"/></g>
<g><path style="opacity:0.997" fill="#ebd18c" d="M 483.5,311.5 C 483.338,313.527 483.505,315.527 484,317.5C 484.71,316.027 485.876,315.36 487.5,315.5C 487.5,318.167 487.5,320.833 487.5,323.5C 489.604,323.201 491.604,323.534 493.5,324.5C 492.585,325.328 491.919,326.328 491.5,327.5C 492.5,329.5 493.5,331.5 494.5,333.5C 495.167,332.833 495.833,332.167 496.5,331.5C 498.361,337.223 501.694,341.89 506.5,345.5C 506.826,349.852 508.493,353.519 511.5,356.5C 509.076,358.714 509.743,359.714 513.5,359.5C 514.002,362.841 515.336,365.841 517.5,368.5C 515.193,370.328 515.526,371.994 518.5,373.5C 523.167,383.5 527.833,393.5 532.5,403.5C 534.5,404.833 536.5,406.167 538.5,407.5C 541.912,414.658 545.578,421.658 549.5,428.5C 547.076,430.714 547.743,431.714 551.5,431.5C 551.238,430.022 551.571,428.689 552.5,427.5C 553.167,430.833 553.833,434.167 554.5,437.5C 555.167,436.167 555.833,434.833 556.5,433.5C 557.73,436.732 559.73,439.399 562.5,441.5C 563.429,442.689 563.762,444.022 563.5,445.5C 564.833,445.5 566.167,445.5 567.5,445.5C 568.644,449.011 570.311,452.344 572.5,455.5C 573.842,457.005 575.508,457.672 577.5,457.5C 577.5,458.833 577.5,460.167 577.5,461.5C 578.833,461.5 580.167,461.5 581.5,461.5C 582.285,464.858 583.285,468.191 584.5,471.5C 585.167,470.833 585.833,470.167 586.5,469.5C 587.43,472.362 589.097,474.695 591.5,476.5C 590.833,477.167 590.167,477.833 589.5,478.5C 592.167,479.167 594.833,479.833 597.5,480.5C 596.833,481.167 596.167,481.833 595.5,482.5C 596.833,483.833 598.167,485.167 599.5,486.5C 598.833,487.167 598.167,487.833 597.5,488.5C 602.197,488.72 605.197,491.054 606.5,495.5C 608.001,496.752 609.668,497.752 611.5,498.5C 610.833,499.167 610.167,499.833 609.5,500.5C 611.332,501.248 612.999,502.248 614.5,503.5C 616.361,509.223 619.694,513.89 624.5,517.5C 628.936,524.177 632.603,531.177 635.5,538.5C 632.833,540.167 630.167,541.833 627.5,543.5C 627.279,544.735 626.612,545.735 625.5,546.5C 622.699,547.32 620.032,548.32 617.5,549.5C 613.89,550.847 613.557,550.18 616.5,547.5C 620.378,546.734 623.378,544.734 625.5,541.5C 623.078,539.06 623.078,536.726 625.5,534.5C 624.167,533.833 622.833,533.167 621.5,532.5C 623.534,530.401 623.868,528.068 622.5,525.5C 621.833,526.167 621.167,526.833 620.5,527.5C 619.534,525.604 619.201,523.604 619.5,521.5C 617.508,521.672 615.842,521.005 614.5,519.5C 613.663,517.156 612.329,515.156 610.5,513.5C 609.534,511.604 609.201,509.604 609.5,507.5C 608.167,507.5 606.833,507.5 605.5,507.5C 604.782,503.758 602.782,500.758 599.5,498.5C 598.311,497.571 596.978,497.238 595.5,497.5C 595.5,495.5 595.5,493.5 595.5,491.5C 592.988,491.577 590.988,490.577 589.5,488.5C 590.167,487.833 590.833,487.167 591.5,486.5C 589.01,484.917 586.343,483.917 583.5,483.5C 582.356,479.989 580.689,476.656 578.5,473.5C 571.356,470.541 567.689,465.208 567.5,457.5C 562.995,456.669 559.995,454.002 558.5,449.5C 552.97,447.306 549.637,443.306 548.5,437.5C 546.695,435.097 544.362,433.43 541.5,432.5C 539.257,428.252 536.257,424.586 532.5,421.5C 531.513,418.232 531.18,414.898 531.5,411.5C 529.5,411.5 527.5,411.5 525.5,411.5C 524.167,404.833 522.833,398.167 521.5,391.5C 518.833,391.5 516.167,391.5 513.5,391.5C 513.813,388.753 513.48,386.086 512.5,383.5C 510.534,379.603 508.2,375.937 505.5,372.5C 507.005,371.158 507.672,369.492 507.5,367.5C 505.396,367.799 503.396,367.466 501.5,366.5C 503.924,364.286 503.257,363.286 499.5,363.5C 499.5,361.5 499.5,359.5 499.5,357.5C 495.743,357.714 495.076,356.714 497.5,354.5C 494.833,353.833 492.167,353.167 489.5,352.5C 490.833,351.833 492.167,351.167 493.5,350.5C 490.426,348.281 489.093,345.281 489.5,341.5C 484.645,342.28 481.811,340.28 481,335.5C 480.333,336.833 479.667,338.167 479,339.5C 478.517,338.552 478.351,337.552 478.5,336.5C 478.196,335.85 477.863,335.183 477.5,334.5C 479.236,330.293 480.569,325.96 481.5,321.5C 481.081,320.328 480.415,319.328 479.5,318.5C 480.5,317.833 481.5,317.167 482.5,316.5C 481.753,314.711 482.086,313.044 483.5,311.5 Z"/></g>
<g><path style="opacity:0.004" fill="#888065" d="M 275.5,333.5 C 277.337,333.639 277.67,334.306 276.5,335.5C 275.702,335.043 275.369,334.376 275.5,333.5 Z"/></g>
<g><path style="opacity:0.997" fill="#f0d898" d="M 616.5,547.5 C 613.557,550.18 613.89,550.847 617.5,549.5C 614.813,551.698 611.813,553.698 608.5,555.5C 607.833,556.833 607.167,558.167 606.5,559.5C 605.914,559.291 605.414,558.957 605,558.5C 597.652,564.685 590.485,571.018 583.5,577.5C 585.388,574.101 587.888,571.101 591,568.5C 591.483,567.552 591.649,566.552 591.5,565.5C 594.292,565.378 596.292,564.044 597.5,561.5C 602.052,559.287 606.052,556.287 609.5,552.5C 608.167,550.5 606.833,548.5 605.5,546.5C 608.167,545.167 608.167,543.833 605.5,542.5C 606.167,541.833 606.833,541.167 607.5,540.5C 606.119,538.365 605.119,536.032 604.5,533.5C 601.526,531.994 601.193,530.328 603.5,528.5C 601.343,526.588 599.009,524.921 596.5,523.5C 595.52,520.914 595.187,518.247 595.5,515.5C 593.396,515.799 591.396,515.466 589.5,514.5C 591.924,512.286 591.257,511.286 587.5,511.5C 587.5,508.833 587.5,506.167 587.5,503.5C 585.396,503.799 583.396,503.466 581.5,502.5C 582.167,501.833 582.833,501.167 583.5,500.5C 579.686,498.256 575.686,496.589 571.5,495.5C 570.016,490.54 568.016,485.874 565.5,481.5C 561.139,481.933 557.805,480.266 555.5,476.5C 554.311,475.571 552.978,475.238 551.5,475.5C 551.813,472.753 551.48,470.086 550.5,467.5C 548.413,465.255 547.079,462.588 546.5,459.5C 545.158,461.005 543.492,461.672 541.5,461.5C 541.813,458.753 541.48,456.086 540.5,453.5C 538.423,452.012 537.423,450.012 537.5,447.5C 533.5,447.5 531.5,445.5 531.5,441.5C 530.167,441.5 528.833,441.5 527.5,441.5C 527.813,438.753 527.48,436.086 526.5,433.5C 525.833,434.167 525.167,434.833 524.5,435.5C 522.423,434.012 521.423,432.012 521.5,429.5C 519.508,429.672 517.842,429.005 516.5,427.5C 514.917,425.01 513.917,422.343 513.5,419.5C 512.167,419.5 510.833,419.5 509.5,419.5C 509.672,417.508 509.005,415.842 507.5,414.5C 508.167,413.833 508.833,413.167 509.5,412.5C 508.012,410.423 506.012,409.423 503.5,409.5C 503.799,407.396 503.466,405.396 502.5,403.5C 500.5,400.833 498.5,398.167 496.5,395.5C 495.571,394.311 495.238,392.978 495.5,391.5C 494.167,391.5 492.833,391.5 491.5,391.5C 491.5,389.5 491.5,387.5 491.5,385.5C 488.657,385.083 485.99,384.083 483.5,382.5C 484.167,381.833 484.833,381.167 485.5,380.5C 481.782,377.384 478.782,373.718 476.5,369.5C 475.833,370.167 475.167,370.833 474.5,371.5C 473.158,369.995 471.492,369.328 469.5,369.5C 470.317,366.086 470.317,363.086 469.5,360.5C 470.548,359.452 471.548,358.452 472.5,357.5C 472.262,361.099 473.262,361.433 475.5,358.5C 474.476,354.96 475.476,351.96 478.5,349.5C 479.248,351.332 480.248,352.999 481.5,354.5C 479.599,355.935 479.266,357.602 480.5,359.5C 481.167,358.833 481.833,358.167 482.5,357.5C 483.833,358.833 485.167,360.167 486.5,361.5C 487.622,365.951 489.622,369.951 492.5,373.5C 493.842,375.005 495.508,375.672 497.5,375.5C 498.833,378.833 500.167,382.167 501.5,385.5C 505.257,385.286 505.924,386.286 503.5,388.5C 504.689,389.429 506.022,389.762 507.5,389.5C 507.5,391.5 507.5,393.5 507.5,395.5C 513.697,395.325 514.363,396.325 509.5,398.5C 510.689,399.429 512.022,399.762 513.5,399.5C 512.773,404.323 514.773,407.323 519.5,408.5C 516.833,409.833 516.833,411.167 519.5,412.5C 518.833,413.167 518.167,413.833 517.5,414.5C 520.362,415.43 522.695,417.097 524.5,419.5C 526.689,422.656 528.356,425.989 529.5,429.5C 533.795,429.279 534.462,430.612 531.5,433.5C 532.666,436.503 534.333,439.17 536.5,441.5C 537.167,440.833 537.833,440.167 538.5,439.5C 539.833,442.167 541.167,444.833 542.5,447.5C 543.842,445.995 545.508,445.328 547.5,445.5C 548.799,449.37 549.466,453.37 549.5,457.5C 550.833,457.5 552.167,457.5 553.5,457.5C 553.286,461.257 554.286,461.924 556.5,459.5C 558.689,462.656 560.356,465.989 561.5,469.5C 562.978,469.238 564.311,469.571 565.5,470.5C 567.42,473.339 569.087,476.339 570.5,479.5C 572.001,480.752 573.668,481.752 575.5,482.5C 578.167,485.833 580.833,489.167 583.5,492.5C 584.689,493.429 586.022,493.762 587.5,493.5C 587.917,496.343 588.917,499.01 590.5,501.5C 591.842,503.005 593.508,503.672 595.5,503.5C 595.238,504.978 595.571,506.311 596.5,507.5C 599.167,510.167 601.833,512.833 604.5,515.5C 605.466,517.396 605.799,519.396 605.5,521.5C 606.833,521.5 608.167,521.5 609.5,521.5C 610.672,526.18 612.672,530.513 615.5,534.5C 612.833,535.833 612.833,537.167 615.5,538.5C 614.833,539.167 614.167,539.833 613.5,540.5C 614.833,541.167 616.167,541.833 617.5,542.5C 615.516,544.046 615.183,545.713 616.5,547.5 Z"/></g>
<g><path style="opacity:0.773" fill="#e4cb96" d="M 547.5,352.5 C 548.267,353.172 548.934,354.005 549.5,355C 549.272,355.399 548.938,355.565 548.5,355.5C 547.596,354.791 547.263,353.791 547.5,352.5 Z"/></g>
<g><path style="opacity:0.997" fill="#e5c97f" d="M 491.5,265.5 C 490.774,269.679 490.774,273.679 491.5,277.5C 493.369,279.635 494.036,282.302 493.5,285.5C 498.876,286.548 501.876,289.882 502.5,295.5C 503.842,293.995 505.508,293.328 507.5,293.5C 507.328,295.492 507.995,297.158 509.5,298.5C 507.995,299.842 507.328,301.508 507.5,303.5C 509.492,303.672 511.158,303.005 512.5,301.5C 513.167,302.167 513.833,302.833 514.5,303.5C 515.732,310.075 518.732,315.742 523.5,320.5C 522.833,321.167 522.167,321.833 521.5,322.5C 526.41,328.724 529.41,335.724 530.5,343.5C 532.587,345.745 533.921,348.412 534.5,351.5C 537.474,353.006 537.807,354.672 535.5,356.5C 537.42,359.339 539.087,362.339 540.5,365.5C 541.833,368.167 543.167,368.167 544.5,365.5C 545.248,367.332 546.248,368.999 547.5,370.5C 545.688,373.899 545.021,377.566 545.5,381.5C 548.892,381.871 551.558,383.537 553.5,386.5C 548.306,388.058 548.306,389.058 553.5,389.5C 553.5,390.833 553.5,392.167 553.5,393.5C 554.833,393.5 556.167,393.5 557.5,393.5C 557.927,396.788 557.26,399.788 555.5,402.5C 558.167,403.167 560.833,403.833 563.5,404.5C 562.833,405.167 562.167,405.833 561.5,406.5C 564.942,409.554 568.942,411.554 573.5,412.5C 571.844,414.329 569.844,415.663 567.5,416.5C 570.167,417.833 570.167,419.167 567.5,420.5C 569.5,421.167 571.5,421.833 573.5,422.5C 572.833,423.167 572.167,423.833 571.5,424.5C 573.5,425.167 575.5,425.833 577.5,426.5C 576.833,427.167 576.167,427.833 575.5,428.5C 577.833,430.833 580.167,433.167 582.5,435.5C 584.457,432.75 587.123,431.25 590.5,431C 589.748,430.329 589.414,429.496 589.5,428.5C 591.5,429.833 593.167,431.5 594.5,433.5C 590.57,432.998 588.237,434.665 587.5,438.5C 589.328,441.313 590.661,444.313 591.5,447.5C 593.5,447.5 595.5,447.5 597.5,447.5C 596.773,452.323 598.773,455.323 603.5,456.5C 602.833,457.167 602.167,457.833 601.5,458.5C 605.833,460.167 608.833,463.167 610.5,467.5C 613.167,470.167 615.833,472.833 618.5,475.5C 619.429,476.689 619.762,478.022 619.5,479.5C 622.535,479.521 624.868,480.854 626.5,483.5C 627.119,486.032 628.119,488.365 629.5,490.5C 627.193,492.328 627.526,493.994 630.5,495.5C 631.842,493.995 633.508,493.328 635.5,493.5C 635.579,495.666 636.246,497.666 637.5,499.5C 637.081,500.672 636.415,501.672 635.5,502.5C 637.805,506.266 641.139,507.933 645.5,507.5C 645.328,509.492 645.995,511.158 647.5,512.5C 645.599,513.935 645.266,515.602 646.5,517.5C 647.809,515.109 648.809,515.109 649.5,517.5C 649.081,518.672 648.415,519.672 647.5,520.5C 648.833,522.5 650.167,524.5 651.5,526.5C 650.833,527.167 650.167,527.833 649.5,528.5C 650.833,529.167 652.167,529.833 653.5,530.5C 649.003,534.632 643.669,536.965 637.5,537.5C 638.108,536.2 638.775,534.867 639.5,533.5C 639.081,532.328 638.415,531.328 637.5,530.5C 638.415,529.672 639.081,528.672 639.5,527.5C 637.775,519.713 633.775,513.38 627.5,508.5C 628.167,507.833 628.833,507.167 629.5,506.5C 627.01,504.917 624.343,503.917 621.5,503.5C 621.672,501.508 621.005,499.842 619.5,498.5C 620.167,497.833 620.833,497.167 621.5,496.5C 619.097,494.695 617.43,492.362 616.5,489.5C 613.167,486.833 609.833,484.167 606.5,481.5C 605.266,479.602 605.599,477.935 607.5,476.5C 605.602,475.266 603.935,475.599 602.5,477.5C 599.863,474.001 598.863,470.001 599.5,465.5C 598.167,465.5 596.833,465.5 595.5,465.5C 596.324,460.555 594.324,457.888 589.5,457.5C 589.5,456.167 589.5,454.833 589.5,453.5C 585.5,453.5 583.5,451.5 583.5,447.5C 580.167,447.5 576.833,447.5 573.5,447.5C 573.82,444.102 573.487,440.768 572.5,437.5C 571.833,438.167 571.167,438.833 570.5,439.5C 569.167,438.167 567.833,436.833 566.5,435.5C 565.558,432.007 564.225,428.674 562.5,425.5C 561.158,423.995 559.492,423.328 557.5,423.5C 557.479,420.465 556.146,418.132 553.5,416.5C 554.167,415.833 554.833,415.167 555.5,414.5C 553.604,413.534 551.604,413.201 549.5,413.5C 547.969,408.308 547.303,402.974 547.5,397.5C 544.159,396.998 541.159,395.664 538.5,393.5C 537.833,388.167 537.167,382.833 536.5,377.5C 534.695,375.097 532.362,373.43 529.5,372.5C 531.924,370.286 531.257,369.286 527.5,369.5C 527.84,366.856 527.173,364.523 525.5,362.5C 526.167,361.833 526.833,361.167 527.5,360.5C 526.167,359.833 524.833,359.167 523.5,358.5C 521.987,355.476 519.987,352.809 517.5,350.5C 518.833,349.167 520.167,347.833 521.5,346.5C 518.833,344.5 516.167,342.5 513.5,340.5C 515.173,338.477 515.84,336.144 515.5,333.5C 513.508,333.328 511.842,333.995 510.5,335.5C 509.52,332.914 509.187,330.247 509.5,327.5C 506.988,327.577 504.988,326.577 503.5,324.5C 504.167,323.833 504.833,323.167 505.5,322.5C 502.833,320.5 502.833,318.5 505.5,316.5C 503.668,315.752 502.001,314.752 500.5,313.5C 499.065,315.401 497.398,315.734 495.5,314.5C 498.167,313.167 498.167,311.833 495.5,310.5C 497.5,309.833 499.5,309.167 501.5,308.5C 497.243,307.19 493.243,305.523 489.5,303.5C 489.843,301.517 489.176,300.183 487.5,299.5C 489.319,292.947 490.152,286.281 490,279.5C 489.218,282.31 488.384,284.977 487.5,287.5C 488.353,279.954 489.686,272.62 491.5,265.5 Z"/></g>
<g><path style="opacity:0.997" fill="#eed592" d="M 616.5,547.5 C 615.183,545.713 615.516,544.046 617.5,542.5C 616.167,541.833 614.833,541.167 613.5,540.5C 614.167,539.833 614.833,539.167 615.5,538.5C 612.833,537.167 612.833,535.833 615.5,534.5C 612.672,530.513 610.672,526.18 609.5,521.5C 608.167,521.5 606.833,521.5 605.5,521.5C 605.799,519.396 605.466,517.396 604.5,515.5C 601.833,512.833 599.167,510.167 596.5,507.5C 595.571,506.311 595.238,504.978 595.5,503.5C 593.508,503.672 591.842,503.005 590.5,501.5C 588.917,499.01 587.917,496.343 587.5,493.5C 586.022,493.762 584.689,493.429 583.5,492.5C 580.833,489.167 578.167,485.833 575.5,482.5C 573.668,481.752 572.001,480.752 570.5,479.5C 569.087,476.339 567.42,473.339 565.5,470.5C 564.311,469.571 562.978,469.238 561.5,469.5C 560.356,465.989 558.689,462.656 556.5,459.5C 554.286,461.924 553.286,461.257 553.5,457.5C 552.167,457.5 550.833,457.5 549.5,457.5C 549.466,453.37 548.799,449.37 547.5,445.5C 545.508,445.328 543.842,445.995 542.5,447.5C 541.167,444.833 539.833,442.167 538.5,439.5C 537.833,440.167 537.167,440.833 536.5,441.5C 534.333,439.17 532.666,436.503 531.5,433.5C 534.462,430.612 533.795,429.279 529.5,429.5C 528.356,425.989 526.689,422.656 524.5,419.5C 522.695,417.097 520.362,415.43 517.5,414.5C 518.167,413.833 518.833,413.167 519.5,412.5C 516.833,411.167 516.833,409.833 519.5,408.5C 514.773,407.323 512.773,404.323 513.5,399.5C 512.022,399.762 510.689,399.429 509.5,398.5C 514.363,396.325 513.697,395.325 507.5,395.5C 507.5,393.5 507.5,391.5 507.5,389.5C 506.022,389.762 504.689,389.429 503.5,388.5C 505.924,386.286 505.257,385.286 501.5,385.5C 500.167,382.167 498.833,378.833 497.5,375.5C 495.508,375.672 493.842,375.005 492.5,373.5C 489.622,369.951 487.622,365.951 486.5,361.5C 485.167,360.167 483.833,358.833 482.5,357.5C 481.833,358.167 481.167,358.833 480.5,359.5C 479.266,357.602 479.599,355.935 481.5,354.5C 480.248,352.999 479.248,351.332 478.5,349.5C 475.476,351.96 474.476,354.96 475.5,358.5C 473.262,361.433 472.262,361.099 472.5,357.5C 473.383,353.19 474.716,348.69 476.5,344C 476.043,343.586 475.709,343.086 475.5,342.5C 476.519,340.396 477.519,338.396 478.5,336.5C 478.351,337.552 478.517,338.552 479,339.5C 479.667,338.167 480.333,336.833 481,335.5C 481.811,340.28 484.645,342.28 489.5,341.5C 489.093,345.281 490.426,348.281 493.5,350.5C 492.167,351.167 490.833,351.833 489.5,352.5C 492.167,353.167 494.833,353.833 497.5,354.5C 495.076,356.714 495.743,357.714 499.5,357.5C 499.5,359.5 499.5,361.5 499.5,363.5C 503.257,363.286 503.924,364.286 501.5,366.5C 503.396,367.466 505.396,367.799 507.5,367.5C 507.672,369.492 507.005,371.158 505.5,372.5C 508.2,375.937 510.534,379.603 512.5,383.5C 513.48,386.086 513.813,388.753 513.5,391.5C 516.167,391.5 518.833,391.5 521.5,391.5C 522.833,398.167 524.167,404.833 525.5,411.5C 527.5,411.5 529.5,411.5 531.5,411.5C 531.18,414.898 531.513,418.232 532.5,421.5C 536.257,424.586 539.257,428.252 541.5,432.5C 544.362,433.43 546.695,435.097 548.5,437.5C 549.637,443.306 552.97,447.306 558.5,449.5C 559.995,454.002 562.995,456.669 567.5,457.5C 567.689,465.208 571.356,470.541 578.5,473.5C 580.689,476.656 582.356,479.989 583.5,483.5C 586.343,483.917 589.01,484.917 591.5,486.5C 590.833,487.167 590.167,487.833 589.5,488.5C 590.988,490.577 592.988,491.577 595.5,491.5C 595.5,493.5 595.5,495.5 595.5,497.5C 596.978,497.238 598.311,497.571 599.5,498.5C 602.782,500.758 604.782,503.758 605.5,507.5C 606.833,507.5 608.167,507.5 609.5,507.5C 609.201,509.604 609.534,511.604 610.5,513.5C 612.329,515.156 613.663,517.156 614.5,519.5C 615.842,521.005 617.508,521.672 619.5,521.5C 619.201,523.604 619.534,525.604 620.5,527.5C 621.167,526.833 621.833,526.167 622.5,525.5C 623.868,528.068 623.534,530.401 621.5,532.5C 622.833,533.167 624.167,533.833 625.5,534.5C 623.078,536.726 623.078,539.06 625.5,541.5C 623.378,544.734 620.378,546.734 616.5,547.5 Z"/></g>
<g><path style="opacity:0.997" fill="#f2dc9e" d="M 469.5,369.5 C 471.492,369.328 473.158,369.995 474.5,371.5C 475.167,370.833 475.833,370.167 476.5,369.5C 478.782,373.718 481.782,377.384 485.5,380.5C 484.833,381.167 484.167,381.833 483.5,382.5C 485.99,384.083 488.657,385.083 491.5,385.5C 491.5,387.5 491.5,389.5 491.5,391.5C 492.833,391.5 494.167,391.5 495.5,391.5C 495.238,392.978 495.571,394.311 496.5,395.5C 498.5,398.167 500.5,400.833 502.5,403.5C 503.466,405.396 503.799,407.396 503.5,409.5C 506.012,409.423 508.012,410.423 509.5,412.5C 508.833,413.167 508.167,413.833 507.5,414.5C 509.005,415.842 509.672,417.508 509.5,419.5C 510.833,419.5 512.167,419.5 513.5,419.5C 513.917,422.343 514.917,425.01 516.5,427.5C 517.842,429.005 519.508,429.672 521.5,429.5C 521.423,432.012 522.423,434.012 524.5,435.5C 525.167,434.833 525.833,434.167 526.5,433.5C 527.48,436.086 527.813,438.753 527.5,441.5C 528.833,441.5 530.167,441.5 531.5,441.5C 531.5,445.5 533.5,447.5 537.5,447.5C 537.423,450.012 538.423,452.012 540.5,453.5C 541.48,456.086 541.813,458.753 541.5,461.5C 543.492,461.672 545.158,461.005 546.5,459.5C 547.079,462.588 548.413,465.255 550.5,467.5C 551.48,470.086 551.813,472.753 551.5,475.5C 552.978,475.238 554.311,475.571 555.5,476.5C 557.805,480.266 561.139,481.933 565.5,481.5C 568.016,485.874 570.016,490.54 571.5,495.5C 575.686,496.589 579.686,498.256 583.5,500.5C 582.833,501.167 582.167,501.833 581.5,502.5C 583.396,503.466 585.396,503.799 587.5,503.5C 587.5,506.167 587.5,508.833 587.5,511.5C 591.257,511.286 591.924,512.286 589.5,514.5C 591.396,515.466 593.396,515.799 595.5,515.5C 595.187,518.247 595.52,520.914 596.5,523.5C 599.009,524.921 601.343,526.588 603.5,528.5C 601.193,530.328 601.526,531.994 604.5,533.5C 605.119,536.032 606.119,538.365 607.5,540.5C 606.833,541.167 606.167,541.833 605.5,542.5C 608.167,543.833 608.167,545.167 605.5,546.5C 606.833,548.5 608.167,550.5 609.5,552.5C 606.052,556.287 602.052,559.287 597.5,561.5C 597.16,558.856 597.827,556.523 599.5,554.5C 598.833,553.833 598.167,553.167 597.5,552.5C 598.415,551.672 599.081,550.672 599.5,549.5C 598.269,544.421 596.936,539.421 595.5,534.5C 597.924,532.286 597.257,531.286 593.5,531.5C 593.5,530.167 593.5,528.833 593.5,527.5C 592.167,527.5 590.833,527.5 589.5,527.5C 589.596,521.916 586.929,518.249 581.5,516.5C 582.833,515.833 584.167,515.167 585.5,514.5C 583.5,513.833 581.5,513.167 579.5,512.5C 577.995,511.158 577.328,509.492 577.5,507.5C 575.508,507.672 573.842,507.005 572.5,505.5C 570.311,502.344 568.644,499.011 567.5,495.5C 565.508,495.672 563.842,495.005 562.5,493.5C 561.833,491.5 561.167,489.5 560.5,487.5C 559.833,488.167 559.167,488.833 558.5,489.5C 555.167,484.833 551.833,480.167 548.5,475.5C 543.5,473.167 539.833,469.5 537.5,464.5C 536.311,463.571 534.978,463.238 533.5,463.5C 533.672,461.508 533.005,459.842 531.5,458.5C 528.268,457.27 525.601,455.27 523.5,452.5C 521.604,451.534 519.604,451.201 517.5,451.5C 517.466,447.37 516.799,443.37 515.5,439.5C 514.167,439.5 512.833,439.5 511.5,439.5C 511.799,437.396 511.466,435.396 510.5,433.5C 507.456,429.018 504.789,424.352 502.5,419.5C 501.833,416.833 501.167,414.167 500.5,411.5C 498.286,413.924 497.286,413.257 497.5,409.5C 495.5,409.5 493.5,409.5 491.5,409.5C 490.669,404.995 488.002,401.995 483.5,400.5C 485.924,398.286 485.257,397.286 481.5,397.5C 481.328,395.508 481.995,393.842 483.5,392.5C 481.604,391.534 479.604,391.201 477.5,391.5C 477.5,390.167 477.5,388.833 477.5,387.5C 475.508,387.672 473.842,387.005 472.5,385.5C 471.833,386.167 471.167,386.833 470.5,387.5C 469.833,385.5 469.167,383.5 468.5,381.5C 464.841,384.812 462.174,388.812 460.5,393.5C 459.735,394.612 458.735,395.279 457.5,395.5C 458.588,393.417 459.588,391.251 460.5,389C 460.167,388.667 459.833,388.333 459.5,388C 461.632,387.082 462.299,385.749 461.5,384C 464.299,381.507 465.633,378.674 465.5,375.5C 466.385,373.023 467.718,371.023 469.5,369.5 Z"/></g>
<g><path style="opacity:0.997" fill="#f6e3ab" d="M 443.5,421.5 C 443.704,419.315 444.37,417.315 445.5,415.5C 448.597,412.797 451.264,409.63 453.5,406C 453.833,405.833 454.167,405.667 454.5,405.5C 455.167,406.833 455.833,408.167 456.5,409.5C 458.577,408.012 459.577,406.012 459.5,403.5C 460.833,403.5 462.167,403.5 463.5,403.5C 463.286,407.257 464.286,407.924 466.5,405.5C 467.167,406.167 467.833,406.833 468.5,407.5C 469.167,405.5 469.833,403.5 470.5,401.5C 471.119,404.032 472.119,406.365 473.5,408.5C 477.436,411.588 481.77,413.922 486.5,415.5C 487.248,417.332 488.248,418.999 489.5,420.5C 487.599,421.935 487.266,423.602 488.5,425.5C 489.935,423.599 491.602,423.266 493.5,424.5C 491.076,426.714 491.743,427.714 495.5,427.5C 495.238,428.978 495.571,430.311 496.5,431.5C 500.5,436.833 504.5,442.167 508.5,447.5C 513.392,452.392 519.058,458.058 525.5,464.5C 524.833,465.167 524.167,465.833 523.5,466.5C 526.032,467.119 528.365,468.119 530.5,469.5C 531.429,470.689 531.762,472.022 531.5,473.5C 535.257,473.286 535.924,474.286 533.5,476.5C 537.5,477.833 540.167,480.5 541.5,484.5C 544.167,485.167 546.833,485.833 549.5,486.5C 548.833,487.167 548.167,487.833 547.5,488.5C 550.167,491.167 552.833,493.833 555.5,496.5C 556.689,497.429 558.022,497.762 559.5,497.5C 559.5,498.833 559.5,500.167 559.5,501.5C 560.833,501.5 562.167,501.5 563.5,501.5C 563.5,502.833 563.5,504.167 563.5,505.5C 564.833,505.5 566.167,505.5 567.5,505.5C 568.44,511.99 571.107,517.657 575.5,522.5C 574.833,523.167 574.167,523.833 573.5,524.5C 576.032,525.119 578.365,526.119 580.5,527.5C 580.395,533.725 582.728,538.725 587.5,542.5C 586.456,543.623 585.79,544.956 585.5,546.5C 587.318,550.078 587.652,553.745 586.5,557.5C 584.999,558.752 583.332,559.752 581.5,560.5C 583.401,561.935 583.734,563.602 582.5,565.5C 580.286,563.076 579.286,563.743 579.5,567.5C 576.248,568.377 572.915,569.043 569.5,569.5C 566.957,569.36 564.623,568.694 562.5,567.5C 561.833,568.167 561.167,568.833 560.5,569.5C 555.833,562.167 549.833,556.167 542.5,551.5C 541.571,550.311 541.238,548.978 541.5,547.5C 537.5,547.5 535.5,545.5 535.5,541.5C 530.833,540.833 528.167,538.167 527.5,533.5C 525.5,533.5 523.5,533.5 521.5,533.5C 521.5,531.5 521.5,529.5 521.5,527.5C 520.167,527.5 518.833,527.5 517.5,527.5C 517.762,526.022 517.429,524.689 516.5,523.5C 512.131,520.643 508.131,517.31 504.5,513.5C 502.775,510.326 501.442,506.993 500.5,503.5C 498.286,505.924 497.286,505.257 497.5,501.5C 493.758,500.782 490.758,498.782 488.5,495.5C 487.571,494.311 487.238,492.978 487.5,491.5C 485.5,491.5 483.5,491.5 481.5,491.5C 478.921,484.412 475.588,477.746 471.5,471.5C 470.167,471.5 468.833,471.5 467.5,471.5C 466.833,468.833 466.167,466.167 465.5,463.5C 463.508,463.672 461.842,463.005 460.5,461.5C 458.553,457.716 457.22,453.716 456.5,449.5C 454.833,447.833 453.167,446.167 451.5,444.5C 453.807,442.672 453.474,441.006 450.5,439.5C 449.881,436.968 448.881,434.635 447.5,432.5C 448.167,431.833 448.833,431.167 449.5,430.5C 448.167,429.167 446.833,427.833 445.5,426.5C 446.689,425.571 448.022,425.238 449.5,425.5C 449.714,421.743 448.714,421.076 446.5,423.5C 445.735,422.388 444.735,421.721 443.5,421.5 Z"/></g>
<g><path style="opacity:0.004" fill="#ebd99f" d="M 443.5,415.5 C 441.663,415.361 441.33,414.694 442.5,413.5C 443.298,413.957 443.631,414.624 443.5,415.5 Z"/></g>
<g><path style="opacity:0.004" fill="#e8d69e" d="M 431.5,423.5 C 433.337,423.639 433.67,424.306 432.5,425.5C 431.702,425.043 431.369,424.376 431.5,423.5 Z"/></g>
<g><path style="opacity:0.997" fill="#f2dc9f" d="M 431.5,433.5 C 432.735,433.721 433.735,434.388 434.5,435.5C 435.047,439.158 436.714,442.158 439.5,444.5C 437.995,445.842 437.328,447.508 437.5,449.5C 438.833,449.5 440.167,449.5 441.5,449.5C 442.576,452.734 443.243,456.068 443.5,459.5C 445.5,459.5 447.5,459.5 449.5,459.5C 449.917,462.343 450.917,465.01 452.5,467.5C 456.587,470.916 459.92,474.916 462.5,479.5C 463.167,478.833 463.833,478.167 464.5,477.5C 465.622,481.951 467.622,485.951 470.5,489.5C 471.842,491.005 473.508,491.672 475.5,491.5C 475.328,493.492 475.995,495.158 477.5,496.5C 480.732,497.73 483.399,499.73 485.5,502.5C 486.689,503.429 488.022,503.762 489.5,503.5C 489.5,505.5 489.5,507.5 489.5,509.5C 492.892,509.871 495.558,511.537 497.5,514.5C 496.833,515.167 496.167,515.833 495.5,516.5C 498.586,520.257 502.252,523.257 506.5,525.5C 507.466,527.396 507.799,529.396 507.5,531.5C 511.858,532.18 515.525,534.18 518.5,537.5C 519.167,536.833 519.833,536.167 520.5,535.5C 522.517,538.55 523.517,541.883 523.5,545.5C 527.5,545.5 529.5,547.5 529.5,551.5C 532.833,552.833 536.167,554.167 539.5,555.5C 539.067,559.861 540.734,563.195 544.5,565.5C 545.429,566.689 545.762,568.022 545.5,569.5C 548.734,570.576 552.068,571.243 555.5,571.5C 555.5,573.5 555.5,575.5 555.5,577.5C 557.492,577.328 559.158,577.995 560.5,579.5C 561.167,578.833 561.833,578.167 562.5,577.5C 563.833,578.833 565.167,580.167 566.5,581.5C 567.167,580.833 567.833,580.167 568.5,579.5C 571.723,583.412 572.057,587.412 569.5,591.5C 569.762,592.978 569.429,594.311 568.5,595.5C 567.323,590.773 564.323,588.773 559.5,589.5C 559.714,585.743 558.714,585.076 556.5,587.5C 553.537,585.558 551.871,582.892 551.5,579.5C 543.529,575.858 537.863,569.858 534.5,561.5C 532.868,558.854 530.535,557.521 527.5,557.5C 527.5,556.167 527.5,554.833 527.5,553.5C 526.022,553.762 524.689,553.429 523.5,552.5C 521.013,550.191 519.013,547.524 517.5,544.5C 514.412,543.921 511.745,542.587 509.5,540.5C 510.167,539.833 510.833,539.167 511.5,538.5C 507.243,537.19 503.243,535.523 499.5,533.5C 498.833,530.833 498.167,528.167 497.5,525.5C 493.142,524.82 489.475,522.82 486.5,519.5C 483.09,515.347 480.757,510.68 479.5,505.5C 478.167,505.5 476.833,505.5 475.5,505.5C 475.5,501.5 473.5,499.5 469.5,499.5C 469.5,495.5 467.5,493.5 463.5,493.5C 463.5,492.167 463.5,490.833 463.5,489.5C 462.167,489.5 460.833,489.5 459.5,489.5C 459.762,488.022 459.429,486.689 458.5,485.5C 453.943,479.739 448.276,475.739 441.5,473.5C 440.167,469.5 438.833,465.5 437.5,461.5C 436.167,461.5 434.833,461.5 433.5,461.5C 433.5,460.167 433.5,458.833 433.5,457.5C 431.508,457.672 429.842,457.005 428.5,455.5C 426.847,450.671 424.514,446.171 421.5,442C 424.37,438.631 427.703,435.797 431.5,433.5 Z"/></g>
<g><path style="opacity:0.997" fill="#e2c479" d="M 594.5,433.5 C 596.167,434.5 597.5,435.833 598.5,437.5C 597.761,437.369 597.094,437.536 596.5,438C 604.307,444.479 612.64,450.146 621.5,455C 620.207,455.49 618.873,455.657 617.5,455.5C 617.5,457.5 617.5,459.5 617.5,461.5C 623.623,463.036 626.957,467.036 627.5,473.5C 629.604,473.201 631.604,473.534 633.5,474.5C 631.076,476.714 631.743,477.714 635.5,477.5C 636.167,482.167 638.833,484.833 643.5,485.5C 643.672,487.492 643.005,489.158 641.5,490.5C 643.396,491.466 645.396,491.799 647.5,491.5C 647.201,493.604 647.534,495.604 648.5,497.5C 653.074,502.644 655.407,508.644 655.5,515.5C 659.117,515.483 662.45,516.483 665.5,518.5C 664.167,519.167 662.833,519.833 661.5,520.5C 663.442,523.463 666.108,525.129 669.5,525.5C 669.5,526.5 669.5,527.5 669.5,528.5C 665.044,529.197 660.71,530.364 656.5,532C 657.448,532.483 658.448,532.649 659.5,532.5C 658.5,533.167 657.5,533.833 656.5,534.5C 649.769,535.471 643.269,537.804 637,541.5C 636.667,541.167 636.333,540.833 636,540.5C 633.42,542.253 630.587,543.253 627.5,543.5C 630.167,541.833 632.833,540.167 635.5,538.5C 636.492,538.672 637.158,538.338 637.5,537.5C 643.669,536.965 649.003,534.632 653.5,530.5C 652.167,529.833 650.833,529.167 649.5,528.5C 650.167,527.833 650.833,527.167 651.5,526.5C 650.167,524.5 648.833,522.5 647.5,520.5C 648.415,519.672 649.081,518.672 649.5,517.5C 648.809,515.109 647.809,515.109 646.5,517.5C 645.266,515.602 645.599,513.935 647.5,512.5C 645.995,511.158 645.328,509.492 645.5,507.5C 641.139,507.933 637.805,506.266 635.5,502.5C 636.415,501.672 637.081,500.672 637.5,499.5C 636.246,497.666 635.579,495.666 635.5,493.5C 633.508,493.328 631.842,493.995 630.5,495.5C 627.526,493.994 627.193,492.328 629.5,490.5C 628.119,488.365 627.119,486.032 626.5,483.5C 624.868,480.854 622.535,479.521 619.5,479.5C 619.762,478.022 619.429,476.689 618.5,475.5C 615.833,472.833 613.167,470.167 610.5,467.5C 608.833,463.167 605.833,460.167 601.5,458.5C 602.167,457.833 602.833,457.167 603.5,456.5C 598.773,455.323 596.773,452.323 597.5,447.5C 595.5,447.5 593.5,447.5 591.5,447.5C 590.661,444.313 589.328,441.313 587.5,438.5C 588.237,434.665 590.57,432.998 594.5,433.5 Z"/></g>
<g><path style="opacity:0.008" fill="#ead49a" d="M 417.5,441.5 C 415.663,441.361 415.33,440.694 416.5,439.5C 417.298,439.957 417.631,440.624 417.5,441.5 Z"/></g>
<g><path style="opacity:0.997" fill="#f0d998" d="M 443.5,415.5 C 444.167,415.5 444.833,415.5 445.5,415.5C 444.37,417.315 443.704,419.315 443.5,421.5C 438.5,424.5 434.5,428.5 431.5,433.5C 427.703,435.797 424.37,438.631 421.5,442C 424.514,446.171 426.847,450.671 428.5,455.5C 429.842,457.005 431.508,457.672 433.5,457.5C 433.5,458.833 433.5,460.167 433.5,461.5C 434.833,461.5 436.167,461.5 437.5,461.5C 438.833,465.5 440.167,469.5 441.5,473.5C 448.276,475.739 453.943,479.739 458.5,485.5C 459.429,486.689 459.762,488.022 459.5,489.5C 460.833,489.5 462.167,489.5 463.5,489.5C 463.5,490.833 463.5,492.167 463.5,493.5C 467.5,493.5 469.5,495.5 469.5,499.5C 473.5,499.5 475.5,501.5 475.5,505.5C 476.833,505.5 478.167,505.5 479.5,505.5C 480.757,510.68 483.09,515.347 486.5,519.5C 489.475,522.82 493.142,524.82 497.5,525.5C 498.167,528.167 498.833,530.833 499.5,533.5C 503.243,535.523 507.243,537.19 511.5,538.5C 510.833,539.167 510.167,539.833 509.5,540.5C 511.745,542.587 514.412,543.921 517.5,544.5C 519.013,547.524 521.013,550.191 523.5,552.5C 524.689,553.429 526.022,553.762 527.5,553.5C 527.5,554.833 527.5,556.167 527.5,557.5C 530.535,557.521 532.868,558.854 534.5,561.5C 537.863,569.858 543.529,575.858 551.5,579.5C 551.871,582.892 553.537,585.558 556.5,587.5C 558.714,585.076 559.714,585.743 559.5,589.5C 564.323,588.773 567.323,590.773 568.5,595.5C 569.429,594.311 569.762,592.978 569.5,591.5C 570.239,591.631 570.906,591.464 571.5,591C 574.623,585.711 578.623,581.211 583.5,577.5C 577.189,587.135 570.523,596.468 563.5,605.5C 562.883,605.611 562.383,605.944 562,606.5C 562.576,600.244 559.743,596.911 553.5,596.5C 551.343,594.588 549.009,592.921 546.5,591.5C 543.833,587.5 541.167,583.5 538.5,579.5C 536.999,578.248 535.332,577.248 533.5,576.5C 536.167,575.167 536.167,573.833 533.5,572.5C 531.604,571.534 529.604,571.201 527.5,571.5C 527.351,567.678 525.351,565.345 521.5,564.5C 522.167,563.833 522.833,563.167 523.5,562.5C 522.167,561.833 520.833,561.167 519.5,560.5C 520.167,559.833 520.833,559.167 521.5,558.5C 519.01,556.917 516.343,555.917 513.5,555.5C 513.5,554.167 513.5,552.833 513.5,551.5C 509.412,550.438 506.079,548.104 503.5,544.5C 501.604,543.534 499.604,543.201 497.5,543.5C 497.328,541.508 497.995,539.842 499.5,538.5C 497.5,537.833 495.5,537.167 493.5,536.5C 494.167,535.833 494.833,535.167 495.5,534.5C 493.01,532.917 490.343,531.917 487.5,531.5C 487.5,530.167 487.5,528.833 487.5,527.5C 486.167,527.5 484.833,527.5 483.5,527.5C 482.167,524.167 480.833,520.833 479.5,517.5C 477.396,517.799 475.396,517.466 473.5,516.5C 474.167,515.833 474.833,515.167 475.5,514.5C 471.5,511.833 467.5,509.167 463.5,506.5C 464.167,505.833 464.833,505.167 465.5,504.5C 463.604,503.534 461.604,503.201 459.5,503.5C 459.672,501.508 459.005,499.842 457.5,498.5C 454.344,496.311 451.011,494.644 447.5,493.5C 447.5,489.5 445.5,487.5 441.5,487.5C 441.5,485.5 441.5,483.5 441.5,481.5C 436.833,480.833 434.167,478.167 433.5,473.5C 429.21,473.025 425.877,471.025 423.5,467.5C 423.919,466.328 424.585,465.328 425.5,464.5C 422.968,463.881 420.635,462.881 418.5,461.5C 417.661,456.278 415.995,451.444 413.5,447C 416.043,445.618 418.043,443.785 419.5,441.5C 428.512,433.819 436.512,425.153 443.5,415.5 Z"/></g>
<g><path style="opacity:0.996" fill="#e9cd85" d="M 486.5,295.5 C 486.036,298.868 486.369,300.202 487.5,299.5C 489.176,300.183 489.843,301.517 489.5,303.5C 493.243,305.523 497.243,307.19 501.5,308.5C 499.5,309.167 497.5,309.833 495.5,310.5C 498.167,311.833 498.167,313.167 495.5,314.5C 497.398,315.734 499.065,315.401 500.5,313.5C 502.001,314.752 503.668,315.752 505.5,316.5C 502.833,318.5 502.833,320.5 505.5,322.5C 504.833,323.167 504.167,323.833 503.5,324.5C 504.988,326.577 506.988,327.577 509.5,327.5C 509.187,330.247 509.52,332.914 510.5,335.5C 511.842,333.995 513.508,333.328 515.5,333.5C 515.84,336.144 515.173,338.477 513.5,340.5C 516.167,342.5 518.833,344.5 521.5,346.5C 520.167,347.833 518.833,349.167 517.5,350.5C 519.987,352.809 521.987,355.476 523.5,358.5C 524.833,359.167 526.167,359.833 527.5,360.5C 526.833,361.167 526.167,361.833 525.5,362.5C 527.173,364.523 527.84,366.856 527.5,369.5C 531.257,369.286 531.924,370.286 529.5,372.5C 532.362,373.43 534.695,375.097 536.5,377.5C 537.167,382.833 537.833,388.167 538.5,393.5C 541.159,395.664 544.159,396.998 547.5,397.5C 547.303,402.974 547.969,408.308 549.5,413.5C 551.604,413.201 553.604,413.534 555.5,414.5C 554.833,415.167 554.167,415.833 553.5,416.5C 556.146,418.132 557.479,420.465 557.5,423.5C 559.492,423.328 561.158,423.995 562.5,425.5C 564.225,428.674 565.558,432.007 566.5,435.5C 567.833,436.833 569.167,438.167 570.5,439.5C 571.167,438.833 571.833,438.167 572.5,437.5C 573.487,440.768 573.82,444.102 573.5,447.5C 576.833,447.5 580.167,447.5 583.5,447.5C 583.5,451.5 585.5,453.5 589.5,453.5C 589.5,454.833 589.5,456.167 589.5,457.5C 594.324,457.888 596.324,460.555 595.5,465.5C 596.833,465.5 598.167,465.5 599.5,465.5C 598.863,470.001 599.863,474.001 602.5,477.5C 603.935,475.599 605.602,475.266 607.5,476.5C 605.599,477.935 605.266,479.602 606.5,481.5C 609.833,484.167 613.167,486.833 616.5,489.5C 617.43,492.362 619.097,494.695 621.5,496.5C 620.833,497.167 620.167,497.833 619.5,498.5C 621.005,499.842 621.672,501.508 621.5,503.5C 624.343,503.917 627.01,504.917 629.5,506.5C 628.833,507.167 628.167,507.833 627.5,508.5C 633.775,513.38 637.775,519.713 639.5,527.5C 639.081,528.672 638.415,529.672 637.5,530.5C 638.415,531.328 639.081,532.328 639.5,533.5C 638.775,534.867 638.108,536.2 637.5,537.5C 637.158,538.338 636.492,538.672 635.5,538.5C 632.603,531.177 628.936,524.177 624.5,517.5C 619.694,513.89 616.361,509.223 614.5,503.5C 612.999,502.248 611.332,501.248 609.5,500.5C 610.167,499.833 610.833,499.167 611.5,498.5C 609.668,497.752 608.001,496.752 606.5,495.5C 605.197,491.054 602.197,488.72 597.5,488.5C 598.167,487.833 598.833,487.167 599.5,486.5C 598.167,485.167 596.833,483.833 595.5,482.5C 596.167,481.833 596.833,481.167 597.5,480.5C 594.833,479.833 592.167,479.167 589.5,478.5C 590.167,477.833 590.833,477.167 591.5,476.5C 589.097,474.695 587.43,472.362 586.5,469.5C 585.833,470.167 585.167,470.833 584.5,471.5C 583.285,468.191 582.285,464.858 581.5,461.5C 580.167,461.5 578.833,461.5 577.5,461.5C 577.5,460.167 577.5,458.833 577.5,457.5C 575.508,457.672 573.842,457.005 572.5,455.5C 570.311,452.344 568.644,449.011 567.5,445.5C 566.167,445.5 564.833,445.5 563.5,445.5C 563.762,444.022 563.429,442.689 562.5,441.5C 559.73,439.399 557.73,436.732 556.5,433.5C 555.833,434.833 555.167,436.167 554.5,437.5C 553.833,434.167 553.167,430.833 552.5,427.5C 551.571,428.689 551.238,430.022 551.5,431.5C 547.743,431.714 547.076,430.714 549.5,428.5C 545.578,421.658 541.912,414.658 538.5,407.5C 536.5,406.167 534.5,404.833 532.5,403.5C 527.833,393.5 523.167,383.5 518.5,373.5C 515.526,371.994 515.193,370.328 517.5,368.5C 515.336,365.841 514.002,362.841 513.5,359.5C 509.743,359.714 509.076,358.714 511.5,356.5C 508.493,353.519 506.826,349.852 506.5,345.5C 501.694,341.89 498.361,337.223 496.5,331.5C 495.833,332.167 495.167,332.833 494.5,333.5C 493.5,331.5 492.5,329.5 491.5,327.5C 491.919,326.328 492.585,325.328 493.5,324.5C 491.604,323.534 489.604,323.201 487.5,323.5C 487.5,320.833 487.5,318.167 487.5,315.5C 485.876,315.36 484.71,316.027 484,317.5C 483.505,315.527 483.338,313.527 483.5,311.5C 483.844,307.772 484.51,304.105 485.5,300.5C 483.285,298.608 483.618,296.941 486.5,295.5 Z"/></g>
<g><path style="opacity:0.997" fill="#ebd18b" d="M 407.5,449.5 C 406.855,450.812 405.855,451.812 404.5,452.5C 403.548,454.045 403.215,455.712 403.5,457.5C 404.978,457.238 406.311,457.571 407.5,458.5C 408.881,460.635 409.881,462.968 410.5,465.5C 411.842,467.005 413.508,467.672 415.5,467.5C 415.286,471.257 416.286,471.924 418.5,469.5C 421.292,474.628 423.625,479.961 425.5,485.5C 428.833,486.833 432.167,488.167 435.5,489.5C 435.328,491.492 435.995,493.158 437.5,494.5C 439.99,496.083 442.657,497.083 445.5,497.5C 445.5,498.833 445.5,500.167 445.5,501.5C 446.833,501.5 448.167,501.5 449.5,501.5C 449.238,502.978 449.571,504.311 450.5,505.5C 453.524,507.013 456.191,509.013 458.5,511.5C 459.429,512.689 459.762,514.022 459.5,515.5C 462.833,516.833 466.167,518.167 469.5,519.5C 469.5,520.833 469.5,522.167 469.5,523.5C 470.978,523.238 472.311,523.571 473.5,524.5C 474.833,526.5 476.167,528.5 477.5,530.5C 478.689,531.429 480.022,531.762 481.5,531.5C 481.521,534.535 482.854,536.868 485.5,538.5C 488.656,540.689 491.989,542.356 495.5,543.5C 495.238,544.978 495.571,546.311 496.5,547.5C 498.809,549.987 501.476,551.987 504.5,553.5C 505.466,555.396 505.799,557.396 505.5,559.5C 506.978,559.238 508.311,559.571 509.5,560.5C 511.601,563.27 514.268,565.27 517.5,566.5C 519.903,568.305 521.57,570.638 522.5,573.5C 529.199,575.853 532.199,580.52 531.5,587.5C 532.833,587.5 534.167,587.5 535.5,587.5C 536.393,595.646 541.06,599.646 549.5,599.5C 551.5,603.5 553.5,607.5 555.5,611.5C 558.833,611.973 561,610.64 562,607.5C 562.464,608.094 562.631,608.761 562.5,609.5C 560.818,612.822 559.151,616.155 557.5,619.5C 557.631,618.761 557.464,618.094 557,617.5C 555.753,620.329 554.253,622.995 552.5,625.5C 550.413,623.255 549.079,620.588 548.5,617.5C 547.833,618.167 547.167,618.833 546.5,619.5C 540.987,614.465 536.987,608.465 534.5,601.5C 526.503,588.543 516.837,576.876 505.5,566.5C 504.311,565.571 502.978,565.238 501.5,565.5C 499.5,561.5 497.5,557.5 495.5,553.5C 492.833,552.833 490.167,552.167 487.5,551.5C 487.762,550.022 487.429,548.689 486.5,547.5C 484.191,545.013 481.524,543.013 478.5,541.5C 477.571,540.311 477.238,538.978 477.5,537.5C 476.022,537.762 474.689,537.429 473.5,536.5C 468.833,531.833 464.167,527.167 459.5,522.5C 458.311,521.571 456.978,521.238 455.5,521.5C 455.762,520.022 455.429,518.689 454.5,517.5C 452.365,516.119 450.032,515.119 447.5,514.5C 446.167,512.5 444.833,510.5 443.5,508.5C 441.604,507.534 439.604,507.201 437.5,507.5C 437.5,505.5 437.5,503.5 437.5,501.5C 434.142,500.715 430.809,499.715 427.5,498.5C 429.924,496.286 429.257,495.286 425.5,495.5C 425.714,491.743 424.714,491.076 422.5,493.5C 419.757,490.68 418.09,487.347 417.5,483.5C 414.833,483.5 412.167,483.5 409.5,483.5C 408.167,479.5 406.833,475.5 405.5,471.5C 402.988,471.577 400.988,470.577 399.5,468.5C 401.005,467.158 401.672,465.492 401.5,463.5C 399.5,463.5 397.5,463.5 395.5,463.5C 395.5,462.167 395.5,460.833 395.5,459.5C 394.209,459.737 393.209,459.404 392.5,458.5C 394.933,457.452 394.933,456.786 392.5,456.5C 396.129,454.542 400.129,452.376 404.5,450C 403.289,449.107 403.289,448.274 404.5,447.5C 405.265,448.612 406.265,449.279 407.5,449.5 Z"/></g>
<g><path style="opacity:0.008" fill="#dbc07e" d="M 630.5,455.5 C 631.833,456.167 631.833,456.167 630.5,455.5 Z"/></g>
<g><path style="opacity:0.996" fill="#dfc073" d="M 598.5,437.5 C 607.494,444.207 616.66,449.874 626,454.5C 630.801,457.142 635.635,459.475 640.5,461.5C 638.545,460.677 636.545,460.51 634.5,461C 637.833,462.333 641.167,463.667 644.5,465C 643.105,467.075 643.438,468.908 645.5,470.5C 643.193,472.328 643.526,473.994 646.5,475.5C 647.167,474.833 647.833,474.167 648.5,473.5C 650.5,478.167 652.5,482.833 654.5,487.5C 657.558,489.957 659.892,492.957 661.5,496.5C 660.833,497.167 660.167,497.833 659.5,498.5C 664.658,500.651 667.991,504.318 669.5,509.5C 674.694,509.942 674.694,510.942 669.5,512.5C 671.99,514.083 674.657,515.083 677.5,515.5C 677.342,518.361 678.008,521.028 679.5,523.5C 679.167,524.167 678.833,524.833 678.5,525.5C 675.596,526.877 672.596,527.877 669.5,528.5C 669.5,527.5 669.5,526.5 669.5,525.5C 666.108,525.129 663.442,523.463 661.5,520.5C 662.833,519.833 664.167,519.167 665.5,518.5C 662.45,516.483 659.117,515.483 655.5,515.5C 655.407,508.644 653.074,502.644 648.5,497.5C 647.534,495.604 647.201,493.604 647.5,491.5C 645.396,491.799 643.396,491.466 641.5,490.5C 643.005,489.158 643.672,487.492 643.5,485.5C 638.833,484.833 636.167,482.167 635.5,477.5C 631.743,477.714 631.076,476.714 633.5,474.5C 631.604,473.534 629.604,473.201 627.5,473.5C 626.957,467.036 623.623,463.036 617.5,461.5C 617.5,459.5 617.5,457.5 617.5,455.5C 618.873,455.657 620.207,455.49 621.5,455C 612.64,450.146 604.307,444.479 596.5,438C 597.094,437.536 597.761,437.369 598.5,437.5 Z"/></g>
<g><path style="opacity:0.997" fill="#e5c97f" d="M 392.5,456.5 C 394.933,456.786 394.933,457.452 392.5,458.5C 389.154,459.896 385.821,461.396 382.5,463C 384.652,464.413 386.986,465.246 389.5,465.5C 389.483,469.117 390.483,472.45 392.5,475.5C 393.842,477.005 395.508,477.672 397.5,477.5C 397.5,479.5 397.5,481.5 397.5,483.5C 402.167,484.167 404.833,486.833 405.5,491.5C 406.833,491.5 408.167,491.5 409.5,491.5C 409.5,492.833 409.5,494.167 409.5,495.5C 410.833,495.5 412.167,495.5 413.5,495.5C 413.5,497.5 413.5,499.5 413.5,501.5C 416.247,501.187 418.914,501.52 421.5,502.5C 420.833,503.167 420.167,503.833 419.5,504.5C 424.002,505.995 426.669,508.995 427.5,513.5C 432.342,514.256 437.009,515.59 441.5,517.5C 441.888,522.324 444.555,524.324 449.5,523.5C 450.833,526.833 452.167,530.167 453.5,533.5C 455.5,533.5 457.5,533.5 459.5,533.5C 459.238,534.978 459.571,536.311 460.5,537.5C 462.5,538.833 464.5,540.167 466.5,541.5C 467.429,542.689 467.762,544.022 467.5,545.5C 469.5,545.5 471.5,545.5 473.5,545.5C 474.833,548.833 476.167,552.167 477.5,555.5C 481.5,556.833 485.5,558.167 489.5,559.5C 489.238,560.978 489.571,562.311 490.5,563.5C 493.833,566.833 497.167,570.167 500.5,573.5C 501.429,574.689 501.762,576.022 501.5,577.5C 504.167,578.167 506.833,578.833 509.5,579.5C 509.187,582.247 509.52,584.914 510.5,587.5C 511.167,586.833 511.833,586.167 512.5,585.5C 513.73,588.732 515.73,591.399 518.5,593.5C 519.167,596.833 519.833,600.167 520.5,603.5C 521.833,606.167 523.167,606.167 524.5,603.5C 524.833,604.167 525.167,604.833 525.5,605.5C 524.246,607.334 523.579,609.334 523.5,611.5C 529.039,613.375 534.372,615.708 539.5,618.5C 541.173,620.523 541.84,622.856 541.5,625.5C 542.833,625.5 544.167,625.5 545.5,625.5C 545.446,628.951 547.113,631.117 550.5,632C 551.252,632.671 551.586,633.504 551.5,634.5C 551.072,637.785 550.072,640.785 548.5,643.5C 548.649,642.448 548.483,641.448 548,640.5C 547.581,641.672 546.915,642.672 546,643.5C 543.449,641.47 540.616,639.803 537.5,638.5C 538.167,637.833 538.833,637.167 539.5,636.5C 533.833,632.167 528.167,627.833 522.5,623.5C 521.752,621.668 520.752,620.001 519.5,618.5C 520.167,617.833 520.833,617.167 521.5,616.5C 520.119,614.365 519.119,612.032 518.5,609.5C 516.5,607.5 514.5,605.5 512.5,603.5C 511.833,604.167 511.167,604.833 510.5,605.5C 508.5,601.5 506.5,597.5 504.5,593.5C 503.158,591.995 501.492,591.328 499.5,591.5C 499.5,589.5 499.5,587.5 499.5,585.5C 498.167,585.5 496.833,585.5 495.5,585.5C 495.5,581.5 493.5,579.5 489.5,579.5C 489.5,577.5 489.5,575.5 489.5,573.5C 488.167,573.5 486.833,573.5 485.5,573.5C 485.5,572.167 485.5,570.833 485.5,569.5C 484.167,569.5 482.833,569.5 481.5,569.5C 479.991,564.318 476.658,560.651 471.5,558.5C 470.248,556.999 469.248,555.332 468.5,553.5C 467.833,554.167 467.167,554.833 466.5,555.5C 465.534,553.604 465.201,551.604 465.5,549.5C 464.022,549.762 462.689,549.429 461.5,548.5C 457.167,544.167 452.833,539.833 448.5,535.5C 447.833,536.167 447.167,536.833 446.5,537.5C 445.752,535.668 444.752,534.001 443.5,532.5C 440.344,530.311 437.011,528.644 433.5,527.5C 433.5,526.167 433.5,524.833 433.5,523.5C 429.139,523.933 425.805,522.266 423.5,518.5C 419.629,516.874 415.629,515.874 411.5,515.5C 411.5,513.5 411.5,511.5 411.5,509.5C 408.068,509.243 404.734,508.576 401.5,507.5C 401.083,504.657 400.083,501.99 398.5,499.5C 397.833,500.167 397.167,500.833 396.5,501.5C 394.999,500.248 393.332,499.248 391.5,498.5C 392.167,497.833 392.833,497.167 393.5,496.5C 389.525,493.862 387.192,490.195 386.5,485.5C 384.588,483.343 382.921,481.009 381.5,478.5C 380.311,477.571 378.978,477.238 377.5,477.5C 377.5,475.5 377.5,473.5 377.5,471.5C 374.918,471.975 372.918,471.308 371.5,469.5C 373.176,468.817 373.843,467.483 373.5,465.5C 374.978,465.762 376.311,465.429 377.5,464.5C 377.043,463.702 376.376,463.369 375.5,463.5C 377.539,462.422 379.706,461.422 382,460.5C 382.333,460.833 382.667,461.167 383,461.5C 386.031,459.651 389.197,457.984 392.5,456.5 Z"/></g>
<g><path style="opacity:0.047" fill="#ddc38d" d="M 658.5,467.5 C 661.228,467.171 663.562,467.837 665.5,469.5C 662.933,469.279 660.599,468.612 658.5,467.5 Z"/></g>
<g><path style="opacity:0.176" fill="#e1ca99" d="M 354.5,469.5 C 353.5,470.167 352.5,470.833 351.5,471.5C 350.167,471.5 348.833,471.5 347.5,471.5C 349.515,470.076 351.848,469.41 354.5,469.5 Z"/></g>
<g><path style="opacity:0.997" fill="#e2c479" d="M 371.5,469.5 C 372.918,471.308 374.918,471.975 377.5,471.5C 377.5,473.5 377.5,475.5 377.5,477.5C 378.978,477.238 380.311,477.571 381.5,478.5C 382.921,481.009 384.588,483.343 386.5,485.5C 387.192,490.195 389.525,493.862 393.5,496.5C 392.833,497.167 392.167,497.833 391.5,498.5C 393.332,499.248 394.999,500.248 396.5,501.5C 397.167,500.833 397.833,500.167 398.5,499.5C 400.083,501.99 401.083,504.657 401.5,507.5C 404.734,508.576 408.068,509.243 411.5,509.5C 411.5,511.5 411.5,513.5 411.5,515.5C 415.629,515.874 419.629,516.874 423.5,518.5C 425.805,522.266 429.139,523.933 433.5,523.5C 433.5,524.833 433.5,526.167 433.5,527.5C 437.011,528.644 440.344,530.311 443.5,532.5C 444.752,534.001 445.752,535.668 446.5,537.5C 447.167,536.833 447.833,536.167 448.5,535.5C 452.833,539.833 457.167,544.167 461.5,548.5C 462.689,549.429 464.022,549.762 465.5,549.5C 465.201,551.604 465.534,553.604 466.5,555.5C 467.167,554.833 467.833,554.167 468.5,553.5C 469.248,555.332 470.248,556.999 471.5,558.5C 476.658,560.651 479.991,564.318 481.5,569.5C 482.833,569.5 484.167,569.5 485.5,569.5C 485.5,570.833 485.5,572.167 485.5,573.5C 486.833,573.5 488.167,573.5 489.5,573.5C 489.5,575.5 489.5,577.5 489.5,579.5C 493.5,579.5 495.5,581.5 495.5,585.5C 496.833,585.5 498.167,585.5 499.5,585.5C 499.5,587.5 499.5,589.5 499.5,591.5C 501.492,591.328 503.158,591.995 504.5,593.5C 506.5,597.5 508.5,601.5 510.5,605.5C 511.167,604.833 511.833,604.167 512.5,603.5C 514.5,605.5 516.5,607.5 518.5,609.5C 519.119,612.032 520.119,614.365 521.5,616.5C 520.833,617.167 520.167,617.833 519.5,618.5C 520.752,620.001 521.752,621.668 522.5,623.5C 528.167,627.833 533.833,632.167 539.5,636.5C 538.833,637.167 538.167,637.833 537.5,638.5C 540.616,639.803 543.449,641.47 546,643.5C 546.915,642.672 547.581,641.672 548,640.5C 548.483,641.448 548.649,642.448 548.5,643.5C 547.691,648.312 546.358,652.979 544.5,657.5C 544.881,655.058 544.214,654.391 542.5,655.5C 541.158,653.995 539.492,653.328 537.5,653.5C 537.577,650.988 536.577,648.988 534.5,647.5C 533.833,648.167 533.167,648.833 532.5,649.5C 530.5,644.833 527.167,641.5 522.5,639.5C 520.483,636.45 519.483,633.117 519.5,629.5C 516.293,629.876 513.627,628.876 511.5,626.5C 512.167,625.833 512.833,625.167 513.5,624.5C 511.995,623.158 511.328,621.492 511.5,619.5C 507.743,619.714 507.076,618.714 509.5,616.5C 507.399,613.73 504.732,611.73 501.5,610.5C 503.924,608.286 503.257,607.286 499.5,607.5C 499.762,606.022 499.429,604.689 498.5,603.5C 495.5,600.5 492.5,597.5 489.5,594.5C 490.167,593.833 490.833,593.167 491.5,592.5C 490.248,590.999 489.248,589.332 488.5,587.5C 487.158,585.995 485.492,585.328 483.5,585.5C 483.5,583.5 483.5,581.5 483.5,579.5C 479.5,579.5 477.5,577.5 477.5,573.5C 474.657,573.083 471.99,572.083 469.5,570.5C 467.892,566.957 465.558,563.957 462.5,561.5C 461.571,560.311 461.238,558.978 461.5,557.5C 460.167,557.5 458.833,557.5 457.5,557.5C 457.5,556.167 457.5,554.833 457.5,553.5C 451.767,553.762 448.433,551.095 447.5,545.5C 444.266,544.424 440.932,543.757 437.5,543.5C 437.131,538.154 434.798,536.82 430.5,539.5C 427.526,537.994 427.193,536.328 429.5,534.5C 426.191,533.285 422.858,532.285 419.5,531.5C 419.5,530.167 419.5,528.833 419.5,527.5C 415.5,527.5 413.5,525.5 413.5,521.5C 411.5,521.5 409.5,521.5 407.5,521.5C 407.577,518.988 406.577,516.988 404.5,515.5C 403.833,516.167 403.167,516.833 402.5,517.5C 401.158,515.995 399.492,515.328 397.5,515.5C 397.5,514.167 397.5,512.833 397.5,511.5C 395.5,511.5 393.5,511.5 391.5,511.5C 391.5,509.5 391.5,507.5 391.5,505.5C 385.971,504.905 380.971,502.905 376.5,499.5C 375.833,500.167 375.167,500.833 374.5,501.5C 373.558,498.007 372.225,494.674 370.5,491.5C 369.833,492.167 369.167,492.833 368.5,493.5C 366.408,490.319 364.075,487.319 361.5,484.5C 362.833,482.5 364.167,480.5 365.5,478.5C 362.984,475.817 360.317,473.317 357.5,471C 362.119,469.1 366.786,468.6 371.5,469.5 Z"/></g>
<g><path style="opacity:0.996" fill="#f4e0a5" d="M 597.5,561.5 C 596.292,564.044 594.292,565.378 591.5,565.5C 591.649,566.552 591.483,567.552 591,568.5C 587.888,571.101 585.388,574.101 583.5,577.5C 578.623,581.211 574.623,585.711 571.5,591C 570.906,591.464 570.239,591.631 569.5,591.5C 572.057,587.412 571.723,583.412 568.5,579.5C 567.833,580.167 567.167,580.833 566.5,581.5C 565.167,580.167 563.833,578.833 562.5,577.5C 561.833,578.167 561.167,578.833 560.5,579.5C 559.158,577.995 557.492,577.328 555.5,577.5C 555.5,575.5 555.5,573.5 555.5,571.5C 552.068,571.243 548.734,570.576 545.5,569.5C 545.762,568.022 545.429,566.689 544.5,565.5C 540.734,563.195 539.067,559.861 539.5,555.5C 536.167,554.167 532.833,552.833 529.5,551.5C 529.5,547.5 527.5,545.5 523.5,545.5C 523.517,541.883 522.517,538.55 520.5,535.5C 519.833,536.167 519.167,536.833 518.5,537.5C 515.525,534.18 511.858,532.18 507.5,531.5C 507.799,529.396 507.466,527.396 506.5,525.5C 502.252,523.257 498.586,520.257 495.5,516.5C 496.167,515.833 496.833,515.167 497.5,514.5C 495.558,511.537 492.892,509.871 489.5,509.5C 489.5,507.5 489.5,505.5 489.5,503.5C 488.022,503.762 486.689,503.429 485.5,502.5C 483.399,499.73 480.732,497.73 477.5,496.5C 475.995,495.158 475.328,493.492 475.5,491.5C 473.508,491.672 471.842,491.005 470.5,489.5C 467.622,485.951 465.622,481.951 464.5,477.5C 463.833,478.167 463.167,478.833 462.5,479.5C 459.92,474.916 456.587,470.916 452.5,467.5C 450.917,465.01 449.917,462.343 449.5,459.5C 447.5,459.5 445.5,459.5 443.5,459.5C 443.243,456.068 442.576,452.734 441.5,449.5C 440.167,449.5 438.833,449.5 437.5,449.5C 437.328,447.508 437.995,445.842 439.5,444.5C 436.714,442.158 435.047,439.158 434.5,435.5C 433.735,434.388 432.735,433.721 431.5,433.5C 434.5,428.5 438.5,424.5 443.5,421.5C 444.735,421.721 445.735,422.388 446.5,423.5C 448.714,421.076 449.714,421.743 449.5,425.5C 448.022,425.238 446.689,425.571 445.5,426.5C 446.833,427.833 448.167,429.167 449.5,430.5C 448.833,431.167 448.167,431.833 447.5,432.5C 448.881,434.635 449.881,436.968 450.5,439.5C 453.474,441.006 453.807,442.672 451.5,444.5C 453.167,446.167 454.833,447.833 456.5,449.5C 457.22,453.716 458.553,457.716 460.5,461.5C 461.842,463.005 463.508,463.672 465.5,463.5C 466.167,466.167 466.833,468.833 467.5,471.5C 468.833,471.5 470.167,471.5 471.5,471.5C 475.588,477.746 478.921,484.412 481.5,491.5C 483.5,491.5 485.5,491.5 487.5,491.5C 487.238,492.978 487.571,494.311 488.5,495.5C 490.758,498.782 493.758,500.782 497.5,501.5C 497.286,505.257 498.286,505.924 500.5,503.5C 501.442,506.993 502.775,510.326 504.5,513.5C 508.131,517.31 512.131,520.643 516.5,523.5C 517.429,524.689 517.762,526.022 517.5,527.5C 518.833,527.5 520.167,527.5 521.5,527.5C 521.5,529.5 521.5,531.5 521.5,533.5C 523.5,533.5 525.5,533.5 527.5,533.5C 528.167,538.167 530.833,540.833 535.5,541.5C 535.5,545.5 537.5,547.5 541.5,547.5C 541.238,548.978 541.571,550.311 542.5,551.5C 549.833,556.167 555.833,562.167 560.5,569.5C 561.167,568.833 561.833,568.167 562.5,567.5C 564.623,568.694 566.957,569.36 569.5,569.5C 572.915,569.043 576.248,568.377 579.5,567.5C 579.286,563.743 580.286,563.076 582.5,565.5C 583.734,563.602 583.401,561.935 581.5,560.5C 583.332,559.752 584.999,558.752 586.5,557.5C 587.652,553.745 587.318,550.078 585.5,546.5C 585.79,544.956 586.456,543.623 587.5,542.5C 582.728,538.725 580.395,533.725 580.5,527.5C 578.365,526.119 576.032,525.119 573.5,524.5C 574.167,523.833 574.833,523.167 575.5,522.5C 571.107,517.657 568.44,511.99 567.5,505.5C 566.167,505.5 564.833,505.5 563.5,505.5C 563.5,504.167 563.5,502.833 563.5,501.5C 562.167,501.5 560.833,501.5 559.5,501.5C 559.5,500.167 559.5,498.833 559.5,497.5C 558.022,497.762 556.689,497.429 555.5,496.5C 552.833,493.833 550.167,491.167 547.5,488.5C 548.167,487.833 548.833,487.167 549.5,486.5C 546.833,485.833 544.167,485.167 541.5,484.5C 540.167,480.5 537.5,477.833 533.5,476.5C 535.924,474.286 535.257,473.286 531.5,473.5C 531.762,472.022 531.429,470.689 530.5,469.5C 528.365,468.119 526.032,467.119 523.5,466.5C 524.167,465.833 524.833,465.167 525.5,464.5C 519.058,458.058 513.392,452.392 508.5,447.5C 504.5,442.167 500.5,436.833 496.5,431.5C 495.571,430.311 495.238,428.978 495.5,427.5C 491.743,427.714 491.076,426.714 493.5,424.5C 491.602,423.266 489.935,423.599 488.5,425.5C 487.266,423.602 487.599,421.935 489.5,420.5C 488.248,418.999 487.248,417.332 486.5,415.5C 481.77,413.922 477.436,411.588 473.5,408.5C 472.119,406.365 471.119,404.032 470.5,401.5C 469.833,403.5 469.167,405.5 468.5,407.5C 467.833,406.833 467.167,406.167 466.5,405.5C 464.286,407.924 463.286,407.257 463.5,403.5C 462.167,403.5 460.833,403.5 459.5,403.5C 459.577,406.012 458.577,408.012 456.5,409.5C 455.833,408.167 455.167,406.833 454.5,405.5C 454.167,405.667 453.833,405.833 453.5,406C 451.264,409.63 448.597,412.797 445.5,415.5C 445.238,414.022 445.571,412.689 446.5,411.5C 450.651,406.439 454.317,401.106 457.5,395.5C 458.735,395.279 459.735,394.612 460.5,393.5C 462.174,388.812 464.841,384.812 468.5,381.5C 469.167,383.5 469.833,385.5 470.5,387.5C 471.167,386.833 471.833,386.167 472.5,385.5C 473.842,387.005 475.508,387.672 477.5,387.5C 477.5,388.833 477.5,390.167 477.5,391.5C 479.604,391.201 481.604,391.534 483.5,392.5C 481.995,393.842 481.328,395.508 481.5,397.5C 485.257,397.286 485.924,398.286 483.5,400.5C 488.002,401.995 490.669,404.995 491.5,409.5C 493.5,409.5 495.5,409.5 497.5,409.5C 497.286,413.257 498.286,413.924 500.5,411.5C 501.167,414.167 501.833,416.833 502.5,419.5C 504.789,424.352 507.456,429.018 510.5,433.5C 511.466,435.396 511.799,437.396 511.5,439.5C 512.833,439.5 514.167,439.5 515.5,439.5C 516.799,443.37 517.466,447.37 517.5,451.5C 519.604,451.201 521.604,451.534 523.5,452.5C 525.601,455.27 528.268,457.27 531.5,458.5C 533.005,459.842 533.672,461.508 533.5,463.5C 534.978,463.238 536.311,463.571 537.5,464.5C 539.833,469.5 543.5,473.167 548.5,475.5C 551.833,480.167 555.167,484.833 558.5,489.5C 559.167,488.833 559.833,488.167 560.5,487.5C 561.167,489.5 561.833,491.5 562.5,493.5C 563.842,495.005 565.508,495.672 567.5,495.5C 568.644,499.011 570.311,502.344 572.5,505.5C 573.842,507.005 575.508,507.672 577.5,507.5C 577.328,509.492 577.995,511.158 579.5,512.5C 581.5,513.167 583.5,513.833 585.5,514.5C 584.167,515.167 582.833,515.833 581.5,516.5C 586.929,518.249 589.596,521.916 589.5,527.5C 590.833,527.5 592.167,527.5 593.5,527.5C 593.5,528.833 593.5,530.167 593.5,531.5C 597.257,531.286 597.924,532.286 595.5,534.5C 596.936,539.421 598.269,544.421 599.5,549.5C 599.081,550.672 598.415,551.672 597.5,552.5C 598.167,553.167 598.833,553.833 599.5,554.5C 597.827,556.523 597.16,558.856 597.5,561.5 Z"/></g>
<g><path style="opacity:0.998" fill="#f7e6b0" d="M 471.5,429.5 C 473.03,431.82 475.03,433.82 477.5,435.5C 478.672,435.081 479.672,434.415 480.5,433.5C 481.02,437.735 483.02,441.068 486.5,443.5C 487.167,442.833 487.833,442.167 488.5,441.5C 491.524,443.013 494.191,445.013 496.5,447.5C 497.429,448.689 497.762,450.022 497.5,451.5C 499.604,451.201 501.604,451.534 503.5,452.5C 502.833,453.167 502.167,453.833 501.5,454.5C 504.079,458.104 507.412,460.438 511.5,461.5C 512.167,464.167 512.833,466.833 513.5,469.5C 514.833,469.5 516.167,469.5 517.5,469.5C 517.328,471.492 517.995,473.158 519.5,474.5C 518.833,475.167 518.167,475.833 517.5,476.5C 519.396,477.466 521.396,477.799 523.5,477.5C 523.672,479.492 523.005,481.158 521.5,482.5C 523.332,483.248 524.999,484.248 526.5,485.5C 528.328,483.193 529.994,483.526 531.5,486.5C 529.604,487.466 527.604,487.799 525.5,487.5C 525.279,491.795 526.612,492.462 529.5,489.5C 534.098,491.77 538.431,494.437 542.5,497.5C 543.167,496.167 543.833,494.833 544.5,493.5C 546.225,496.674 547.558,500.007 548.5,503.5C 549.833,506.167 551.167,506.167 552.5,503.5C 553.73,506.732 555.73,509.399 558.5,511.5C 561.574,519.575 565.907,526.908 571.5,533.5C 570.638,535.087 569.971,536.754 569.5,538.5C 570.701,541.71 572.701,544.377 575.5,546.5C 574.167,547.167 572.833,547.833 571.5,548.5C 573.5,549.167 575.5,549.833 577.5,550.5C 576.167,551.167 574.833,551.833 573.5,552.5C 575.005,553.842 575.672,555.508 575.5,557.5C 574.167,557.5 572.833,557.5 571.5,557.5C 571.058,552.306 570.058,552.306 568.5,557.5C 567.833,556.833 567.167,556.167 566.5,555.5C 564.942,560.694 563.942,560.694 563.5,555.5C 562.167,555.5 560.833,555.5 559.5,555.5C 559.675,549.303 558.675,548.637 556.5,553.5C 555.158,551.995 553.492,551.328 551.5,551.5C 551.5,549.5 551.5,547.5 551.5,545.5C 548.833,544.833 546.167,544.167 543.5,543.5C 543.5,541.5 543.5,539.5 543.5,537.5C 542.022,537.762 540.689,537.429 539.5,536.5C 536.532,533.353 533.198,530.686 529.5,528.5C 531.924,526.286 531.257,525.286 527.5,525.5C 527.5,524.167 527.5,522.833 527.5,521.5C 526.167,521.5 524.833,521.5 523.5,521.5C 522.833,518.833 522.167,516.167 521.5,513.5C 515.303,513.675 514.637,512.675 519.5,510.5C 517.668,509.752 516.001,508.752 514.5,507.5C 513.833,508.167 513.167,508.833 512.5,509.5C 511.52,506.914 511.187,504.247 511.5,501.5C 507.989,500.356 504.656,498.689 501.5,496.5C 500.119,494.365 499.119,492.032 498.5,489.5C 497.833,490.167 497.167,490.833 496.5,491.5C 495.534,489.604 495.201,487.604 495.5,485.5C 494.167,485.5 492.833,485.5 491.5,485.5C 491.5,484.167 491.5,482.833 491.5,481.5C 487.743,481.714 487.076,480.714 489.5,478.5C 486.833,475.167 484.167,471.833 481.5,468.5C 480.311,467.571 478.978,467.238 477.5,467.5C 476.824,462.792 475.824,458.125 474.5,453.5C 473.833,454.833 473.167,456.167 472.5,457.5C 472.167,456.5 471.833,455.5 471.5,454.5C 472.967,450.968 473.634,447.302 473.5,443.5C 474.833,443.5 476.167,443.5 477.5,443.5C 477.762,442.022 477.429,440.689 476.5,439.5C 475.377,440.544 474.044,441.21 472.5,441.5C 470.051,440.775 467.717,439.775 465.5,438.5C 466.988,436.423 468.988,435.423 471.5,435.5C 471.5,433.5 471.5,431.5 471.5,429.5 Z"/></g>
<g><path style="opacity:0.996" fill="#dfc073" d="M 375.5,463.5 C 376.376,463.369 377.043,463.702 377.5,464.5C 376.311,465.429 374.978,465.762 373.5,465.5C 373.843,467.483 373.176,468.817 371.5,469.5C 366.786,468.6 362.119,469.1 357.5,471C 360.317,473.317 362.984,475.817 365.5,478.5C 364.167,480.5 362.833,482.5 361.5,484.5C 364.075,487.319 366.408,490.319 368.5,493.5C 369.167,492.833 369.833,492.167 370.5,491.5C 372.225,494.674 373.558,498.007 374.5,501.5C 375.167,500.833 375.833,500.167 376.5,499.5C 380.971,502.905 385.971,504.905 391.5,505.5C 391.5,507.5 391.5,509.5 391.5,511.5C 393.5,511.5 395.5,511.5 397.5,511.5C 397.5,512.833 397.5,514.167 397.5,515.5C 399.492,515.328 401.158,515.995 402.5,517.5C 403.167,516.833 403.833,516.167 404.5,515.5C 406.577,516.988 407.577,518.988 407.5,521.5C 409.5,521.5 411.5,521.5 413.5,521.5C 413.5,525.5 415.5,527.5 419.5,527.5C 419.5,528.833 419.5,530.167 419.5,531.5C 422.858,532.285 426.191,533.285 429.5,534.5C 427.193,536.328 427.526,537.994 430.5,539.5C 434.798,536.82 437.131,538.154 437.5,543.5C 440.932,543.757 444.266,544.424 447.5,545.5C 448.433,551.095 451.767,553.762 457.5,553.5C 457.5,554.833 457.5,556.167 457.5,557.5C 458.833,557.5 460.167,557.5 461.5,557.5C 461.238,558.978 461.571,560.311 462.5,561.5C 465.558,563.957 467.892,566.957 469.5,570.5C 471.99,572.083 474.657,573.083 477.5,573.5C 477.5,577.5 479.5,579.5 483.5,579.5C 483.5,581.5 483.5,583.5 483.5,585.5C 485.492,585.328 487.158,585.995 488.5,587.5C 489.248,589.332 490.248,590.999 491.5,592.5C 490.833,593.167 490.167,593.833 489.5,594.5C 492.5,597.5 495.5,600.5 498.5,603.5C 499.429,604.689 499.762,606.022 499.5,607.5C 503.257,607.286 503.924,608.286 501.5,610.5C 504.732,611.73 507.399,613.73 509.5,616.5C 507.076,618.714 507.743,619.714 511.5,619.5C 511.328,621.492 511.995,623.158 513.5,624.5C 512.833,625.167 512.167,625.833 511.5,626.5C 513.627,628.876 516.293,629.876 519.5,629.5C 519.483,633.117 520.483,636.45 522.5,639.5C 527.167,641.5 530.5,644.833 532.5,649.5C 533.167,648.833 533.833,648.167 534.5,647.5C 536.577,648.988 537.577,650.988 537.5,653.5C 539.492,653.328 541.158,653.995 542.5,655.5C 544.214,654.391 544.881,655.058 544.5,657.5C 544.384,660.392 543.718,663.392 542.5,666.5C 542.336,660.833 542.003,660.5 541.5,665.5C 538.833,666.167 536.167,666.833 533.5,667.5C 533.714,663.743 532.714,663.076 530.5,665.5C 528.413,663.255 527.079,660.588 526.5,657.5C 525.833,658.167 525.167,658.833 524.5,659.5C 521.442,657.043 519.108,654.043 517.5,650.5C 519.924,648.286 519.257,647.286 515.5,647.5C 515.5,646.167 515.5,644.833 515.5,643.5C 513.508,643.672 511.842,643.005 510.5,641.5C 508.917,639.01 507.917,636.343 507.5,633.5C 503.743,633.714 503.076,632.714 505.5,630.5C 502.833,629.833 500.167,629.167 497.5,628.5C 498.167,627.833 498.833,627.167 499.5,626.5C 498.167,625.167 496.833,623.833 495.5,622.5C 496.167,621.833 496.833,621.167 497.5,620.5C 495.126,618.461 493.126,616.128 491.5,613.5C 494.462,610.612 493.795,609.279 489.5,609.5C 489.5,607.5 489.5,605.5 489.5,603.5C 488.167,603.5 486.833,603.5 485.5,603.5C 482.811,599.106 480.478,594.44 478.5,589.5C 477.065,591.401 475.398,591.734 473.5,590.5C 475.807,588.672 475.474,587.006 472.5,585.5C 471.571,584.311 471.238,582.978 471.5,581.5C 470.167,581.5 468.833,581.5 467.5,581.5C 467.5,580.167 467.5,578.833 467.5,577.5C 466.022,577.762 464.689,577.429 463.5,576.5C 460.833,573.167 458.167,569.833 455.5,566.5C 453.668,565.752 452.001,564.752 450.5,563.5C 449.833,564.167 449.167,564.833 448.5,565.5C 447.558,562.007 446.225,558.674 444.5,555.5C 443.833,556.167 443.167,556.833 442.5,557.5C 435.661,550.998 427.995,545.664 419.5,541.5C 418.328,541.919 417.328,542.585 416.5,543.5C 415.833,541.5 415.167,539.5 414.5,537.5C 413.833,538.167 413.167,538.833 412.5,539.5C 410.365,538.119 408.032,537.119 405.5,536.5C 406.167,535.833 406.833,535.167 407.5,534.5C 405.129,531.794 402.463,529.461 399.5,527.5C 397.666,528.754 395.666,529.421 393.5,529.5C 393.5,528.167 393.5,526.833 393.5,525.5C 391.508,525.328 389.842,525.995 388.5,527.5C 387.266,525.602 387.599,523.935 389.5,522.5C 387.604,521.534 385.604,521.201 383.5,521.5C 383.5,520.167 383.5,518.833 383.5,517.5C 379.142,516.82 375.475,514.82 372.5,511.5C 371.191,513.891 370.191,513.891 369.5,511.5C 369.919,510.328 370.585,509.328 371.5,508.5C 369.994,505.526 368.328,505.193 366.5,507.5C 365.5,506.5 364.5,505.5 363.5,504.5C 364.833,503.833 366.167,503.167 367.5,502.5C 364.638,501.57 362.305,499.903 360.5,497.5C 358.286,499.924 357.286,499.257 357.5,495.5C 356.167,495.5 354.833,495.5 353.5,495.5C 353.328,493.508 353.995,491.842 355.5,490.5C 353.399,487.73 350.732,485.73 347.5,484.5C 349.534,482.401 349.868,480.068 348.5,477.5C 347.158,475.995 345.492,475.328 343.5,475.5C 343.762,476.978 343.429,478.311 342.5,479.5C 341.158,477.995 339.492,477.328 337.5,477.5C 337.47,476.503 337.97,475.836 339,475.5C 343.497,474.815 347.664,473.482 351.5,471.5C 352.5,470.833 353.5,470.167 354.5,469.5C 361.719,468.693 368.719,466.693 375.5,463.5 Z"/></g>
<g><path style="opacity:0.996" fill="#daba6c" d="M 640.5,461.5 C 644.358,462.033 648.358,463.367 652.5,465.5C 653.696,465.154 653.696,464.654 652.5,464C 653.448,463.517 654.448,463.351 655.5,463.5C 655.5,464.5 655.5,465.5 655.5,466.5C 656.791,466.263 657.791,466.596 658.5,467.5C 660.599,468.612 662.933,469.279 665.5,469.5C 670.084,470.164 674.75,471.164 679.5,472.5C 673.052,472.435 673.052,473.268 679.5,475C 684.827,475.943 690.16,476.777 695.5,477.5C 695.5,478.833 694.833,479.5 693.5,479.5C 692.265,479.721 691.265,480.388 690.5,481.5C 689.571,480.311 689.238,478.978 689.5,477.5C 684.915,478.013 680.582,477.346 676.5,475.5C 675.167,476.833 673.833,478.167 672.5,479.5C 670.672,477.193 669.006,477.526 667.5,480.5C 669.627,482.876 672.293,483.876 675.5,483.5C 675.124,486.707 676.124,489.373 678.5,491.5C 680.714,489.076 681.714,489.743 681.5,493.5C 677.205,493.279 676.538,494.612 679.5,497.5C 679.081,498.672 678.415,499.672 677.5,500.5C 680.588,501.079 683.255,502.413 685.5,504.5C 684.833,505.167 684.167,505.833 683.5,506.5C 685.5,507.167 687.5,507.833 689.5,508.5C 688.311,509.429 686.978,509.762 685.5,509.5C 685.5,510.833 685.5,512.167 685.5,513.5C 686.833,513.5 688.167,513.5 689.5,513.5C 689.328,515.492 689.995,517.158 691.5,518.5C 695.445,519.491 699.445,519.824 703.5,519.5C 703.38,520.586 702.713,521.253 701.5,521.5C 697.819,522.27 694.152,523.103 690.5,524C 691.448,524.483 692.448,524.649 693.5,524.5C 693.5,524.833 693.5,525.167 693.5,525.5C 687.918,526.379 682.584,527.712 677.5,529.5C 676.265,529.721 675.265,530.388 674.5,531.5C 673.833,530.833 673.167,530.167 672.5,529.5C 671.28,530.711 670.113,530.711 669,529.5C 666.2,531.495 663.033,532.495 659.5,532.5C 658.448,532.649 657.448,532.483 656.5,532C 660.71,530.364 665.044,529.197 669.5,528.5C 672.596,527.877 675.596,526.877 678.5,525.5C 678.833,524.833 679.167,524.167 679.5,523.5C 678.008,521.028 677.342,518.361 677.5,515.5C 674.657,515.083 671.99,514.083 669.5,512.5C 674.694,510.942 674.694,509.942 669.5,509.5C 667.991,504.318 664.658,500.651 659.5,498.5C 660.167,497.833 660.833,497.167 661.5,496.5C 659.892,492.957 657.558,489.957 654.5,487.5C 652.5,482.833 650.5,478.167 648.5,473.5C 647.833,474.167 647.167,474.833 646.5,475.5C 643.526,473.994 643.193,472.328 645.5,470.5C 643.438,468.908 643.105,467.075 644.5,465C 641.167,463.667 637.833,462.333 634.5,461C 636.545,460.51 638.545,460.677 640.5,461.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d2b469" d="M 689.5,471.5 C 691.337,471.639 691.67,472.306 690.5,473.5C 689.702,473.043 689.369,472.376 689.5,471.5 Z"/></g>
<g><path style="opacity:0.086" fill="#dbc188" d="M 687.5,474.5 C 685.901,474.768 684.568,474.434 683.5,473.5C 684.031,472.205 685.364,471.538 687.5,471.5C 687.5,472.5 687.5,473.5 687.5,474.5 Z"/></g>
<g><path style="opacity:0.906" fill="#ddc283" d="M 690.5,475.5 C 690.735,474.903 691.235,474.57 692,474.5C 694.03,474.954 695.863,475.62 697.5,476.5C 695.097,476.552 692.764,476.219 690.5,475.5 Z"/></g>
<g><path style="opacity:0.998" fill="#d1a84e" d="M 679.5,472.5 C 681.099,472.232 682.432,472.566 683.5,473.5C 684.568,474.434 685.901,474.768 687.5,474.5C 688.609,474.557 689.609,474.89 690.5,475.5C 692.764,476.219 695.097,476.552 697.5,476.5C 698.167,476.5 698.833,476.5 699.5,476.5C 700.833,477.167 702.167,477.833 703.5,478.5C 700.763,478.599 698.096,478.265 695.5,477.5C 690.16,476.777 684.827,475.943 679.5,475C 673.052,473.268 673.052,472.435 679.5,472.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d2b060" d="M 695.5,477.5 C 698.096,478.265 700.763,478.599 703.5,478.5C 705.735,478.205 707.735,478.539 709.5,479.5C 710.568,480.434 711.901,480.768 713.5,480.5C 713.5,482.167 713.5,483.833 713.5,485.5C 721.5,487.5 721.5,489.5 713.5,491.5C 713.5,492.833 713.5,494.167 713.5,495.5C 714.833,495.5 716.167,495.5 717.5,495.5C 717.286,499.257 718.286,499.924 720.5,497.5C 721.775,499.717 722.775,502.051 723.5,504.5C 723.21,506.044 722.544,507.377 721.5,508.5C 723.396,509.466 725.396,509.799 727.5,509.5C 727.5,510.833 727.5,512.167 727.5,513.5C 726.167,513.5 724.833,513.5 723.5,513.5C 723.5,515.167 723.5,516.833 723.5,518.5C 719.868,518.15 717.201,518.816 715.5,520.5C 715.5,520.833 715.5,521.167 715.5,521.5C 712.702,522.395 710.036,522.728 707.5,522.5C 702.759,522.735 698.092,523.402 693.5,524.5C 692.448,524.649 691.448,524.483 690.5,524C 694.152,523.103 697.819,522.27 701.5,521.5C 702.713,521.253 703.38,520.586 703.5,519.5C 705.83,517.508 707.164,514.841 707.5,511.5C 706.418,506.085 705.085,500.751 703.5,495.5C 703.919,494.328 704.585,493.328 705.5,492.5C 703.01,490.917 700.343,489.917 697.5,489.5C 697.328,487.508 697.995,485.842 699.5,484.5C 696.615,483.746 694.615,482.08 693.5,479.5C 694.833,479.5 695.5,478.833 695.5,477.5 Z"/></g>
<g><path style="opacity:0.384" fill="#dcc490" d="M 699.5,476.5 C 705.407,476.863 711.073,477.863 716.5,479.5C 714.167,479.5 711.833,479.5 709.5,479.5C 707.735,478.539 705.735,478.205 703.5,478.5C 702.167,477.833 700.833,477.167 699.5,476.5 Z"/></g>
<g><path style="opacity:0.008" fill="#cbac5d" d="M 730.5,479.5 C 731.833,480.167 731.833,480.167 730.5,479.5 Z"/></g>
<g><path style="opacity:0.039" fill="#dfc998" d="M 309.5,479.5 C 303.858,480.354 298.191,481.02 292.5,481.5C 297.115,480.094 301.949,479.094 307,478.5C 308.07,478.528 308.903,478.861 309.5,479.5 Z"/></g>
<g><path style="opacity:0.796" fill="#d8bf86" d="M 291.5,481.5 C 290.081,482.451 288.415,482.784 286.5,482.5C 287.868,481.694 289.201,480.694 290.5,479.5C 290.787,480.2 291.12,480.867 291.5,481.5 Z"/></g>
<g><path style="opacity:1" fill="#cea753" d="M 709.5,479.5 C 711.833,479.5 714.167,479.5 716.5,479.5C 721.63,480.437 726.63,481.104 731.5,481.5C 732.263,482.268 733.263,482.768 734.5,483C 727.348,483.475 720.348,482.641 713.5,480.5C 711.901,480.768 710.568,480.434 709.5,479.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d3b163" d="M 317.5,479.5 C 319.025,481.036 321.025,482.036 323.5,482.5C 322.833,483.167 322.167,483.833 321.5,484.5C 322.833,486.5 324.167,488.5 325.5,490.5C 320.167,491.833 320.167,493.167 325.5,494.5C 322.078,496.766 321.078,499.766 322.5,503.5C 323.935,501.599 325.602,501.266 327.5,502.5C 324.833,503.833 324.833,505.167 327.5,506.5C 326.833,507.167 326.167,507.833 325.5,508.5C 327.167,510.167 328.833,511.833 330.5,513.5C 331.167,512.833 331.833,512.167 332.5,511.5C 333.842,513.005 335.508,513.672 337.5,513.5C 337.5,514.833 337.5,516.167 337.5,517.5C 341.257,517.286 341.924,518.286 339.5,520.5C 341.844,521.337 343.844,522.671 345.5,524.5C 344.757,525.182 344.091,525.849 343.5,526.5C 339.612,525.027 335.612,524.527 331.5,525C 333.058,525.21 334.391,525.71 335.5,526.5C 331.575,526.57 327.909,525.903 324.5,524.5C 326.199,524.66 327.866,524.494 329.5,524C 322.273,521.967 314.939,520.967 307.5,521C 309.058,521.21 310.391,521.71 311.5,522.5C 307.267,522.461 303.267,521.795 299.5,520.5C 301.857,520.663 304.19,520.497 306.5,520C 305.552,519.517 304.552,519.351 303.5,519.5C 303.328,517.508 303.995,515.842 305.5,514.5C 303.995,513.158 303.328,511.492 303.5,509.5C 302.167,509.5 300.833,509.5 299.5,509.5C 299.672,507.508 299.005,505.842 297.5,504.5C 299.5,503.833 301.5,503.167 303.5,502.5C 300.412,501.921 297.745,500.587 295.5,498.5C 296.689,497.571 298.022,497.238 299.5,497.5C 299.5,496.167 299.5,494.833 299.5,493.5C 298.167,493.5 296.833,493.5 295.5,493.5C 295.5,490.833 295.5,488.167 295.5,485.5C 294.022,485.762 292.689,485.429 291.5,484.5C 300.04,482.188 308.706,480.521 317.5,479.5 Z"/></g>
<g><path style="opacity:0.996" fill="#cdab5b" d="M 713.5,480.5 C 720.348,482.641 727.348,483.475 734.5,483C 733.263,482.768 732.263,482.268 731.5,481.5C 734.01,481.054 736.01,481.72 737.5,483.5C 736.761,483.369 736.094,483.536 735.5,484C 745.904,486.151 756.57,487.651 767.5,488.5C 765.735,489.461 763.735,489.795 761.5,489.5C 761.328,491.492 761.995,493.158 763.5,494.5C 762.167,495.167 760.833,495.833 759.5,496.5C 761.664,499.159 762.998,502.159 763.5,505.5C 765.604,505.201 767.604,505.534 769.5,506.5C 768.833,507.167 768.167,507.833 767.5,508.5C 768.612,509.265 769.279,510.265 769.5,511.5C 766.572,511.565 763.905,512.232 761.5,513.5C 761.158,514.338 760.492,514.672 759.5,514.5C 752.906,513.501 746.239,514.001 739.5,516C 741.81,516.497 744.143,516.663 746.5,516.5C 740.047,518.042 733.38,519.042 726.5,519.5C 722.802,519.552 719.135,519.886 715.5,520.5C 717.201,518.816 719.868,518.15 723.5,518.5C 723.5,516.833 723.5,515.167 723.5,513.5C 724.833,513.5 726.167,513.5 727.5,513.5C 727.5,512.167 727.5,510.833 727.5,509.5C 725.396,509.799 723.396,509.466 721.5,508.5C 722.544,507.377 723.21,506.044 723.5,504.5C 722.775,502.051 721.775,499.717 720.5,497.5C 718.286,499.924 717.286,499.257 717.5,495.5C 716.167,495.5 714.833,495.5 713.5,495.5C 713.5,494.167 713.5,492.833 713.5,491.5C 721.5,489.5 721.5,487.5 713.5,485.5C 713.5,483.833 713.5,482.167 713.5,480.5 Z"/></g>
<g><path style="opacity:0.984" fill="#c79e46" d="M 743.5,483.5 C 747.919,484.972 752.586,485.638 757.5,485.5C 758.167,485.5 758.833,485.5 759.5,485.5C 762.909,486.903 766.575,487.57 770.5,487.5C 769.791,488.404 768.791,488.737 767.5,488.5C 756.57,487.651 745.904,486.151 735.5,484C 736.094,483.536 736.761,483.369 737.5,483.5C 739.653,482.427 741.653,482.427 743.5,483.5 Z"/></g>
<g><path style="opacity:0.761" fill="#d9bc83" d="M 743.5,483.5 C 748.391,483.532 753.057,484.199 757.5,485.5C 752.586,485.638 747.919,484.972 743.5,483.5 Z"/></g>
<g><path style="opacity:0.976" fill="#d3b87d" d="M 263.5,485.5 C 259.119,487.211 254.453,487.877 249.5,487.5C 253.964,486.356 258.63,485.69 263.5,485.5 Z"/></g>
<g><path style="opacity:0.635" fill="#d9c18e" d="M 759.5,485.5 C 769.083,486.042 778.416,487.375 787.5,489.5C 782.833,489.167 778.167,488.833 773.5,488.5C 772.791,487.596 771.791,487.263 770.5,487.5C 766.575,487.57 762.909,486.903 759.5,485.5 Z"/></g>
<g><path style="opacity:0.008" fill="#cdb375" d="M 231.5,489.5 C 232.492,489.328 233.158,489.662 233.5,490.5C 231.167,490.5 228.833,490.5 226.5,490.5C 226.908,489.357 227.575,488.357 228.5,487.5C 229.265,488.612 230.265,489.279 231.5,489.5 Z"/></g>
<g><path style="opacity:0.996" fill="#c8a456" d="M 271.5,484.5 C 274.187,484.336 276.854,484.503 279.5,485C 275.886,485.945 272.219,486.612 268.5,487C 269.352,489.206 270.352,491.373 271.5,493.5C 271.167,494.167 270.833,494.833 270.5,495.5C 269.158,493.995 267.492,493.328 265.5,493.5C 266.239,497.382 267.572,501.049 269.5,504.5C 268.167,505.167 266.833,505.833 265.5,506.5C 266.167,507.167 266.833,507.833 267.5,508.5C 265.359,510.204 263.359,511.87 261.5,513.5C 257.035,512.264 252.701,512.264 248.5,513.5C 245.39,512.912 242.39,512.245 239.5,511.5C 230.347,509.853 221.013,508.52 211.5,507.5C 211.5,506.167 211.5,504.833 211.5,503.5C 218.318,504.001 224.985,503.335 231.5,501.5C 232.833,502.167 234.167,502.833 235.5,503.5C 236.167,503.167 236.833,502.833 237.5,502.5C 236.012,500.423 234.012,499.423 231.5,499.5C 231.5,498.167 231.5,496.833 231.5,495.5C 228.102,495.82 224.768,495.487 221.5,494.5C 226.069,493.015 230.736,491.848 235.5,491C 234.906,490.536 234.239,490.369 233.5,490.5C 233.158,489.662 232.492,489.328 231.5,489.5C 231.804,487.204 232.804,486.871 234.5,488.5C 239.566,489.716 244.566,489.383 249.5,487.5C 254.453,487.877 259.119,487.211 263.5,485.5C 266.211,484.757 268.877,484.423 271.5,484.5 Z"/></g>
<g><path style="opacity:0.996" fill="#cdab5d" d="M 311.5,478.5 C 313.735,478.205 315.735,478.539 317.5,479.5C 308.706,480.521 300.04,482.188 291.5,484.5C 292.689,485.429 294.022,485.762 295.5,485.5C 295.5,488.167 295.5,490.833 295.5,493.5C 296.833,493.5 298.167,493.5 299.5,493.5C 299.5,494.833 299.5,496.167 299.5,497.5C 298.022,497.238 296.689,497.571 295.5,498.5C 297.745,500.587 300.412,501.921 303.5,502.5C 301.5,503.167 299.5,503.833 297.5,504.5C 299.005,505.842 299.672,507.508 299.5,509.5C 300.833,509.5 302.167,509.5 303.5,509.5C 303.328,511.492 303.995,513.158 305.5,514.5C 303.995,515.842 303.328,517.508 303.5,519.5C 293.281,517.264 282.947,516.098 272.5,516C 274.058,516.21 275.391,516.71 276.5,517.5C 271.63,517.31 266.964,516.644 262.5,515.5C 265.518,515.665 268.518,515.498 271.5,515C 268.173,514.39 264.839,513.89 261.5,513.5C 263.359,511.87 265.359,510.204 267.5,508.5C 266.833,507.833 266.167,507.167 265.5,506.5C 266.833,505.833 268.167,505.167 269.5,504.5C 267.572,501.049 266.239,497.382 265.5,493.5C 267.492,493.328 269.158,493.995 270.5,495.5C 270.833,494.833 271.167,494.167 271.5,493.5C 270.352,491.373 269.352,489.206 268.5,487C 272.219,486.612 275.886,485.945 279.5,485C 276.854,484.503 274.187,484.336 271.5,484.5C 275.728,483.6 280.061,482.6 284.5,481.5C 285.183,481.863 285.85,482.196 286.5,482.5C 288.415,482.784 290.081,482.451 291.5,481.5C 291.833,481.5 292.167,481.5 292.5,481.5C 298.191,481.02 303.858,480.354 309.5,479.5C 310.167,479.167 310.833,478.833 311.5,478.5 Z"/></g>
<g><path style="opacity:0.008" fill="#c1a052" d="M 789.5,487.5 C 790.833,488.167 790.833,488.167 789.5,487.5 Z"/></g>
<g><path style="opacity:0.933" fill="#dabf86" d="M 249.5,487.5 C 244.566,489.383 239.566,489.716 234.5,488.5C 239.25,487.983 244.25,487.649 249.5,487.5 Z"/></g>
<g><path style="opacity:0.004" fill="#bfa05b" d="M 211.5,491.5 C 209.663,491.361 209.33,490.694 210.5,489.5C 211.298,489.957 211.631,490.624 211.5,491.5 Z"/></g>
<g><path style="opacity:0.988" fill="#c79f4b" d="M 773.5,488.5 C 778.167,488.833 782.833,489.167 787.5,489.5C 793.544,489.869 799.21,490.536 804.5,491.5C 806.265,492.461 808.265,492.795 810.5,492.5C 809.378,493.156 808.045,493.489 806.5,493.5C 794.04,492.527 783.04,490.861 773.5,488.5 Z"/></g>
<g><path style="opacity:0.004" fill="#bfa35c" d="M 817.5,489.5 C 819.337,489.639 819.67,490.306 818.5,491.5C 817.702,491.043 817.369,490.376 817.5,489.5 Z"/></g>
<g><path style="opacity:0.016" fill="#d3b884" d="M 804.5,491.5 C 809.766,491.189 814.766,491.855 819.5,493.5C 816.455,493.492 813.455,493.159 810.5,492.5C 808.265,492.795 806.265,492.461 804.5,491.5 Z"/></g>
<g><path style="opacity:0.996" fill="#ceb27c" d="M 209.5,492.5 C 203.114,494.468 196.448,495.468 189.5,495.5C 195.953,493.958 202.62,492.958 209.5,492.5 Z"/></g>
<g><path style="opacity:0.995" fill="#c39f53" d="M 226.5,490.5 C 228.833,490.5 231.167,490.5 233.5,490.5C 234.239,490.369 234.906,490.536 235.5,491C 230.736,491.848 226.069,493.015 221.5,494.5C 224.768,495.487 228.102,495.82 231.5,495.5C 231.5,496.833 231.5,498.167 231.5,499.5C 234.012,499.423 236.012,500.423 237.5,502.5C 236.833,502.833 236.167,503.167 235.5,503.5C 234.167,502.833 232.833,502.167 231.5,501.5C 224.985,503.335 218.318,504.001 211.5,503.5C 211.5,504.833 211.5,506.167 211.5,507.5C 205.176,506.704 198.842,505.871 192.5,505C 191.833,502.333 191.167,499.667 190.5,497C 188.19,496.503 185.857,496.337 183.5,496.5C 185.265,495.539 187.265,495.205 189.5,495.5C 196.448,495.468 203.114,494.468 209.5,492.5C 210.492,492.672 211.158,492.338 211.5,491.5C 216.507,491.249 221.507,490.916 226.5,490.5 Z"/></g>
<g><path style="opacity:0.996" fill="#eed592" d="M 417.5,441.5 C 418.167,441.5 418.833,441.5 419.5,441.5C 418.043,443.785 416.043,445.618 413.5,447C 415.995,451.444 417.661,456.278 418.5,461.5C 420.635,462.881 422.968,463.881 425.5,464.5C 424.585,465.328 423.919,466.328 423.5,467.5C 425.877,471.025 429.21,473.025 433.5,473.5C 434.167,478.167 436.833,480.833 441.5,481.5C 441.5,483.5 441.5,485.5 441.5,487.5C 445.5,487.5 447.5,489.5 447.5,493.5C 451.011,494.644 454.344,496.311 457.5,498.5C 459.005,499.842 459.672,501.508 459.5,503.5C 461.604,503.201 463.604,503.534 465.5,504.5C 464.833,505.167 464.167,505.833 463.5,506.5C 467.5,509.167 471.5,511.833 475.5,514.5C 474.833,515.167 474.167,515.833 473.5,516.5C 475.396,517.466 477.396,517.799 479.5,517.5C 480.833,520.833 482.167,524.167 483.5,527.5C 484.833,527.5 486.167,527.5 487.5,527.5C 487.5,528.833 487.5,530.167 487.5,531.5C 490.343,531.917 493.01,532.917 495.5,534.5C 494.833,535.167 494.167,535.833 493.5,536.5C 495.5,537.167 497.5,537.833 499.5,538.5C 497.995,539.842 497.328,541.508 497.5,543.5C 499.604,543.201 501.604,543.534 503.5,544.5C 506.079,548.104 509.412,550.438 513.5,551.5C 513.5,552.833 513.5,554.167 513.5,555.5C 516.343,555.917 519.01,556.917 521.5,558.5C 520.833,559.167 520.167,559.833 519.5,560.5C 520.833,561.167 522.167,561.833 523.5,562.5C 522.833,563.167 522.167,563.833 521.5,564.5C 525.351,565.345 527.351,567.678 527.5,571.5C 529.604,571.201 531.604,571.534 533.5,572.5C 536.167,573.833 536.167,575.167 533.5,576.5C 535.332,577.248 536.999,578.248 538.5,579.5C 541.167,583.5 543.833,587.5 546.5,591.5C 549.009,592.921 551.343,594.588 553.5,596.5C 559.743,596.911 562.576,600.244 562,606.5C 562.383,605.944 562.883,605.611 563.5,605.5C 564.443,607.001 564.109,608.335 562.5,609.5C 562.631,608.761 562.464,608.094 562,607.5C 561,610.64 558.833,611.973 555.5,611.5C 553.5,607.5 551.5,603.5 549.5,599.5C 541.06,599.646 536.393,595.646 535.5,587.5C 534.167,587.5 532.833,587.5 531.5,587.5C 532.199,580.52 529.199,575.853 522.5,573.5C 521.57,570.638 519.903,568.305 517.5,566.5C 514.268,565.27 511.601,563.27 509.5,560.5C 508.311,559.571 506.978,559.238 505.5,559.5C 505.799,557.396 505.466,555.396 504.5,553.5C 501.476,551.987 498.809,549.987 496.5,547.5C 495.571,546.311 495.238,544.978 495.5,543.5C 491.989,542.356 488.656,540.689 485.5,538.5C 482.854,536.868 481.521,534.535 481.5,531.5C 480.022,531.762 478.689,531.429 477.5,530.5C 476.167,528.5 474.833,526.5 473.5,524.5C 472.311,523.571 470.978,523.238 469.5,523.5C 469.5,522.167 469.5,520.833 469.5,519.5C 466.167,518.167 462.833,516.833 459.5,515.5C 459.762,514.022 459.429,512.689 458.5,511.5C 456.191,509.013 453.524,507.013 450.5,505.5C 449.571,504.311 449.238,502.978 449.5,501.5C 448.167,501.5 446.833,501.5 445.5,501.5C 445.5,500.167 445.5,498.833 445.5,497.5C 442.657,497.083 439.99,496.083 437.5,494.5C 435.995,493.158 435.328,491.492 435.5,489.5C 432.167,488.167 428.833,486.833 425.5,485.5C 423.625,479.961 421.292,474.628 418.5,469.5C 416.286,471.924 415.286,471.257 415.5,467.5C 413.508,467.672 411.842,467.005 410.5,465.5C 409.881,462.968 408.881,460.635 407.5,458.5C 406.311,457.571 404.978,457.238 403.5,457.5C 403.215,455.712 403.548,454.045 404.5,452.5C 405.855,451.812 406.855,450.812 407.5,449.5C 409.374,447.885 410.708,445.885 411.5,443.5C 413.898,443.741 415.898,443.074 417.5,441.5 Z"/></g>
<g><path style="opacity:0.995" fill="#c9a658" d="M 770.5,487.5 C 771.791,487.263 772.791,487.596 773.5,488.5C 783.04,490.861 794.04,492.527 806.5,493.5C 808.045,493.489 809.378,493.156 810.5,492.5C 813.455,493.159 816.455,493.492 819.5,493.5C 824.414,493.362 829.081,494.028 833.5,495.5C 831.473,495.338 829.473,495.505 827.5,496C 830.789,496.882 834.123,497.548 837.5,498C 839.605,499.335 840.271,501.002 839.5,503C 841.134,503.494 842.801,503.66 844.5,503.5C 841.091,504.903 837.425,505.57 833.5,505.5C 834.952,504.698 836.618,504.198 838.5,504C 836.833,503.833 835.167,503.667 833.5,503.5C 826.982,503.732 821.316,504.732 816.5,506.5C 816.5,506.833 816.5,507.167 816.5,507.5C 814.059,508.756 811.726,508.756 809.5,507.5C 813.36,507.097 813.193,506.764 809,506.5C 805.5,507 802,507.5 798.5,508C 801.146,508.497 803.813,508.664 806.5,508.5C 804.5,509.167 802.5,509.833 800.5,510.5C 800.167,510.5 799.833,510.5 799.5,510.5C 799.158,509.662 798.492,509.328 797.5,509.5C 796.378,508.844 795.045,508.511 793.5,508.5C 789.827,508.953 786.16,509.453 782.5,510C 783.448,510.483 784.448,510.649 785.5,510.5C 785.5,510.833 785.5,511.167 785.5,511.5C 782.57,512.299 779.57,512.632 776.5,512.5C 777.952,511.698 779.618,511.198 781.5,511C 778.443,510.744 775.443,510.244 772.5,509.5C 771.735,510.612 770.735,511.279 769.5,511.5C 769.279,510.265 768.612,509.265 767.5,508.5C 768.167,507.833 768.833,507.167 769.5,506.5C 767.604,505.534 765.604,505.201 763.5,505.5C 762.998,502.159 761.664,499.159 759.5,496.5C 760.833,495.833 762.167,495.167 763.5,494.5C 761.995,493.158 761.328,491.492 761.5,489.5C 763.735,489.795 765.735,489.461 767.5,488.5C 768.791,488.737 769.791,488.404 770.5,487.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d6b566" d="M 693.5,479.5 C 694.615,482.08 696.615,483.746 699.5,484.5C 697.995,485.842 697.328,487.508 697.5,489.5C 700.343,489.917 703.01,490.917 705.5,492.5C 704.585,493.328 703.919,494.328 703.5,495.5C 705.085,500.751 706.418,506.085 707.5,511.5C 707.164,514.841 705.83,517.508 703.5,519.5C 699.445,519.824 695.445,519.491 691.5,518.5C 689.995,517.158 689.328,515.492 689.5,513.5C 688.167,513.5 686.833,513.5 685.5,513.5C 685.5,512.167 685.5,510.833 685.5,509.5C 686.978,509.762 688.311,509.429 689.5,508.5C 687.5,507.833 685.5,507.167 683.5,506.5C 684.167,505.833 684.833,505.167 685.5,504.5C 683.255,502.413 680.588,501.079 677.5,500.5C 678.415,499.672 679.081,498.672 679.5,497.5C 676.538,494.612 677.205,493.279 681.5,493.5C 681.714,489.743 680.714,489.076 678.5,491.5C 676.124,489.373 675.124,486.707 675.5,483.5C 672.293,483.876 669.627,482.876 667.5,480.5C 669.006,477.526 670.672,477.193 672.5,479.5C 673.833,478.167 675.167,476.833 676.5,475.5C 680.582,477.346 684.915,478.013 689.5,477.5C 689.238,478.978 689.571,480.311 690.5,481.5C 691.265,480.388 692.265,479.721 693.5,479.5 Z"/></g>
<g><path style="opacity:0.604" fill="#ccb27e" d="M 833.5,495.5 C 837.728,496.041 841.894,496.041 846,495.5C 847.402,496.645 848.569,497.978 849.5,499.5C 844.056,498.139 838.723,496.806 833.5,495.5 Z"/></g>
<g><path style="opacity:0.953" fill="#c6ac73" d="M 183.5,496.5 C 181.401,497.612 179.067,498.279 176.5,498.5C 175.833,498.5 175.167,498.5 174.5,498.5C 175.318,495.428 176.485,495.095 178,497.5C 179.699,496.594 181.533,496.261 183.5,496.5 Z"/></g>
<g><path style="opacity:0.993" fill="#c0994a" d="M 183.5,496.5 C 185.857,496.337 188.19,496.503 190.5,497C 191.167,499.667 191.833,502.333 192.5,505C 198.842,505.871 205.176,506.704 211.5,507.5C 221.013,508.52 230.347,509.853 239.5,511.5C 236.167,511.5 232.833,511.5 229.5,511.5C 225.766,511.677 222.099,511.344 218.5,510.5C 213.766,508.855 208.766,508.189 203.5,508.5C 200.615,508.806 197.948,508.473 195.5,507.5C 190.731,506.111 185.731,505.444 180.5,505.5C 179.391,504.71 178.058,504.21 176.5,504C 178.441,503.257 180.274,503.424 182,504.5C 184.412,503.044 186.912,501.71 189.5,500.5C 188.975,499.808 188.308,499.308 187.5,499C 183.638,498.945 179.972,498.778 176.5,498.5C 179.067,498.279 181.401,497.612 183.5,496.5 Z"/></g>
<g><path style="opacity:0.989" fill="#c19c4b" d="M 833.5,495.5 C 838.723,496.806 844.056,498.139 849.5,499.5C 850.833,500.167 850.833,500.833 849.5,501.5C 847.847,501.66 846.514,502.326 845.5,503.5C 845.167,503.5 844.833,503.5 844.5,503.5C 842.801,503.66 841.134,503.494 839.5,503C 840.271,501.002 839.605,499.335 837.5,498C 834.123,497.548 830.789,496.882 827.5,496C 829.473,495.505 831.473,495.338 833.5,495.5 Z"/></g>
<g><path style="opacity:0.004" fill="#af975e" d="M 851.5,499.5 C 853.337,499.639 853.67,500.306 852.5,501.5C 851.702,501.043 851.369,500.376 851.5,499.5 Z"/></g>
<g><path style="opacity:0.984" fill="#be9d55" d="M 174.5,498.5 C 175.167,498.5 175.833,498.5 176.5,498.5C 179.972,498.778 183.638,498.945 187.5,499C 188.308,499.308 188.975,499.808 189.5,500.5C 186.912,501.71 184.412,503.044 182,504.5C 180.274,503.424 178.441,503.257 176.5,504C 178.058,504.21 179.391,504.71 180.5,505.5C 176.259,505.815 172.426,504.815 169,502.5C 168.383,501.551 168.549,500.718 169.5,500C 171.025,498.991 172.692,498.491 174.5,498.5 Z"/></g>
<g><path style="opacity:0.102" fill="#c6ae78" d="M 849.5,501.5 C 848.817,503.176 847.483,503.843 845.5,503.5C 846.514,502.326 847.847,501.66 849.5,501.5 Z"/></g>
<g><path style="opacity:0.995" fill="#d8b86a" d="M 347.5,471.5 C 348.833,471.5 350.167,471.5 351.5,471.5C 347.664,473.482 343.497,474.815 339,475.5C 337.97,475.836 337.47,476.503 337.5,477.5C 337.5,480.167 337.5,482.833 337.5,485.5C 340.012,485.423 342.012,486.423 343.5,488.5C 341.5,489.167 339.5,489.833 337.5,490.5C 338.921,493.009 340.588,495.343 342.5,497.5C 343.167,496.167 343.833,494.833 344.5,493.5C 344.726,498.448 346.726,502.448 350.5,505.5C 352.5,504.167 354.5,502.833 356.5,501.5C 357.429,502.689 357.762,504.022 357.5,505.5C 356.022,505.238 354.689,505.571 353.5,506.5C 355.745,508.587 358.412,509.921 361.5,510.5C 359.109,511.809 359.109,512.809 361.5,513.5C 362.672,513.081 363.672,512.415 364.5,511.5C 367.474,513.006 367.807,514.672 365.5,516.5C 371.844,520.004 377.844,524.004 383.5,528.5C 380.185,528.982 377.518,530.482 375.5,533C 375.645,533.772 375.978,534.439 376.5,535C 375.207,535.49 373.873,535.657 372.5,535.5C 367.95,534.537 363.617,533.203 359.5,531.5C 363.893,531.543 364.226,531.043 360.5,530C 354.859,528.639 349.192,527.472 343.5,526.5C 344.091,525.849 344.757,525.182 345.5,524.5C 343.844,522.671 341.844,521.337 339.5,520.5C 341.924,518.286 341.257,517.286 337.5,517.5C 337.5,516.167 337.5,514.833 337.5,513.5C 335.508,513.672 333.842,513.005 332.5,511.5C 331.833,512.167 331.167,512.833 330.5,513.5C 328.833,511.833 327.167,510.167 325.5,508.5C 326.167,507.833 326.833,507.167 327.5,506.5C 324.833,505.167 324.833,503.833 327.5,502.5C 325.602,501.266 323.935,501.599 322.5,503.5C 321.078,499.766 322.078,496.766 325.5,494.5C 320.167,493.167 320.167,491.833 325.5,490.5C 324.167,488.5 322.833,486.5 321.5,484.5C 322.167,483.833 322.833,483.167 323.5,482.5C 321.025,482.036 319.025,481.036 317.5,479.5C 315.735,478.539 313.735,478.205 311.5,478.5C 322.97,475.798 334.97,473.465 347.5,471.5 Z"/></g>
<g><path style="opacity:0.996" fill="#be9740" d="M 833.5,505.5 C 832.833,505.5 832.167,505.5 831.5,505.5C 826.493,505.751 821.493,506.084 816.5,506.5C 821.316,504.732 826.982,503.732 833.5,503.5C 835.167,503.667 836.833,503.833 838.5,504C 836.618,504.198 834.952,504.698 833.5,505.5 Z"/></g>
<g><path style="opacity:0.012" fill="#ccb17f" d="M 180.5,505.5 C 185.731,505.444 190.731,506.111 195.5,507.5C 190.234,507.811 185.234,507.145 180.5,505.5 Z"/></g>
<g><path style="opacity:0.988" fill="#ba8f31" d="M 809.5,507.5 C 808.391,507.557 807.391,507.89 806.5,508.5C 803.813,508.664 801.146,508.497 798.5,508C 802,507.5 805.5,507 809,506.5C 813.193,506.764 813.36,507.097 809.5,507.5 Z"/></g>
<g><path style="opacity:0.208" fill="#d2b887" d="M 831.5,505.5 C 826.75,507.031 821.75,507.698 816.5,507.5C 816.5,507.167 816.5,506.833 816.5,506.5C 821.493,506.084 826.493,505.751 831.5,505.5 Z"/></g>
<g><path style="opacity:0.004" fill="#bc9f5f" d="M 838.5,506.5 C 839.833,507.167 839.833,507.167 838.5,506.5 Z"/></g>
<g><path style="opacity:0.004" fill="#bda05d" d="M 827.5,507.5 C 829.337,507.639 829.67,508.306 828.5,509.5C 827.702,509.043 827.369,508.376 827.5,507.5 Z"/></g>
<g><path style="opacity:0.986" fill="#c09432" d="M 797.5,509.5 C 793.481,509.646 789.481,509.979 785.5,510.5C 784.448,510.649 783.448,510.483 782.5,510C 786.16,509.453 789.827,508.953 793.5,508.5C 795.045,508.511 796.378,508.844 797.5,509.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c2a358" d="M 817.5,509.5 C 816.833,508.167 816.833,508.167 817.5,509.5 Z"/></g>
<g><path style="opacity:0.008" fill="#d3b57f" d="M 203.5,508.5 C 208.766,508.189 213.766,508.855 218.5,510.5C 216.208,510.244 214.041,510.577 212,511.5C 209.323,509.959 206.49,508.959 203.5,508.5 Z"/></g>
<g><path style="opacity:0.024" fill="#dbc18b" d="M 797.5,509.5 C 798.492,509.328 799.158,509.662 799.5,510.5C 794.833,510.833 790.167,511.167 785.5,511.5C 785.5,511.167 785.5,510.833 785.5,510.5C 789.481,509.979 793.481,509.646 797.5,509.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c3a25c" d="M 809.5,509.5 C 811.337,509.639 811.67,510.306 810.5,511.5C 809.702,511.043 809.369,510.376 809.5,509.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c1a35b" d="M 817.5,509.5 C 819.337,509.639 819.67,510.306 818.5,511.5C 817.702,511.043 817.369,510.376 817.5,509.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c2a459" d="M 800.5,510.5 C 801.833,511.167 801.833,511.167 800.5,510.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c4a55d" d="M 803.5,510.5 C 804.833,511.167 804.833,511.167 803.5,510.5 Z"/></g>
<g><path style="opacity:0.973" fill="#d3b986" d="M 229.5,511.5 C 232.833,511.5 236.167,511.5 239.5,511.5C 242.39,512.245 245.39,512.912 248.5,513.5C 253.049,513.624 257.382,514.291 261.5,515.5C 250.637,514.642 239.97,513.309 229.5,511.5 Z"/></g>
<g><path style="opacity:0.996" fill="#c2993b" d="M 776.5,512.5 C 776.167,512.5 775.833,512.5 775.5,512.5C 772.615,512.194 769.948,512.527 767.5,513.5C 765.5,513.5 763.5,513.5 761.5,513.5C 763.905,512.232 766.572,511.565 769.5,511.5C 770.735,511.279 771.735,510.612 772.5,509.5C 775.443,510.244 778.443,510.744 781.5,511C 779.618,511.198 777.952,511.698 776.5,512.5 Z"/></g>
<g><path style="opacity:0.275" fill="#d3b77d" d="M 767.5,513.5 C 769.948,512.527 772.615,512.194 775.5,512.5C 775.539,513.756 775.039,514.756 774,515.5C 772.246,513.75 770.079,513.083 767.5,513.5 Z"/></g>
<g><path style="opacity:0.98" fill="#c39940" d="M 248.5,513.5 C 252.701,512.264 257.035,512.264 261.5,513.5C 264.839,513.89 268.173,514.39 271.5,515C 268.518,515.498 265.518,515.665 262.5,515.5C 262.167,515.5 261.833,515.5 261.5,515.5C 257.382,514.291 253.049,513.624 248.5,513.5 Z"/></g>
<g><path style="opacity:0.973" fill="#caa14b" d="M 759.5,514.5 C 757.901,514.232 756.568,514.566 755.5,515.5C 752.57,516.299 749.57,516.632 746.5,516.5C 744.143,516.663 741.81,516.497 739.5,516C 746.239,514.001 752.906,513.501 759.5,514.5 Z"/></g>
<g><path style="opacity:0.224" fill="#dabe8f" d="M 761.5,513.5 C 763.5,513.5 765.5,513.5 767.5,513.5C 763.764,514.989 759.764,515.656 755.5,515.5C 756.568,514.566 757.901,514.232 759.5,514.5C 760.492,514.672 761.158,514.338 761.5,513.5 Z"/></g>
<g><path style="opacity:0.008" fill="#caa961" d="M 758.5,516.5 C 759.833,517.167 759.833,517.167 758.5,516.5 Z"/></g>
<g><path style="opacity:0.992" fill="#cea857" d="M 303.5,519.5 C 304.552,519.351 305.552,519.517 306.5,520C 304.19,520.497 301.857,520.663 299.5,520.5C 291.931,520.183 284.265,519.183 276.5,517.5C 275.391,516.71 274.058,516.21 272.5,516C 282.947,516.098 293.281,517.264 303.5,519.5 Z"/></g>
<g><path style="opacity:0.441" fill="#d8be8c" d="M 726.5,519.5 C 723.054,520.687 719.387,521.354 715.5,521.5C 715.5,521.167 715.5,520.833 715.5,520.5C 719.135,519.886 722.802,519.552 726.5,519.5 Z"/></g>
<g><path style="opacity:0.988" fill="#cba03f" d="M 324.5,524.5 C 323.833,524.167 323.167,523.833 322.5,523.5C 318.881,522.756 315.215,522.423 311.5,522.5C 310.391,521.71 309.058,521.21 307.5,521C 314.939,520.967 322.273,521.967 329.5,524C 327.866,524.494 326.199,524.66 324.5,524.5 Z"/></g>
<g><path style="opacity:0.004" fill="#cbab63" d="M 303.5,522.5 C 304.833,523.167 304.833,523.167 303.5,522.5 Z"/></g>
<g><path style="opacity:0.796" fill="#dbc08a" d="M 311.5,523.5 C 311.5,523.167 311.5,522.833 311.5,522.5C 315.215,522.423 318.881,522.756 322.5,523.5C 319.023,524.119 315.356,524.119 311.5,523.5 Z"/></g>
<g><path style="opacity:0.004" fill="#cbab62" d="M 311.5,523.5 C 311.361,525.337 310.694,525.67 309.5,524.5C 309.957,523.702 310.624,523.369 311.5,523.5 Z"/></g>
<g><path style="opacity:0.098" fill="#ddc187" d="M 707.5,522.5 C 705.833,523.167 704.167,523.833 702.5,524.5C 699.421,525.282 696.421,525.615 693.5,525.5C 693.5,525.167 693.5,524.833 693.5,524.5C 698.092,523.402 702.759,522.735 707.5,522.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d0b167" d="M 702.5,524.5 C 703.833,525.167 703.833,525.167 702.5,524.5 Z"/></g>
<g><path style="opacity:1" fill="#d3aa50" d="M 343.5,526.5 C 349.192,527.472 354.859,528.639 360.5,530C 364.226,531.043 363.893,531.543 359.5,531.5C 358.833,531.5 358.167,531.5 357.5,531.5C 355.485,530.076 353.152,529.41 350.5,529.5C 350.167,529.5 349.833,529.5 349.5,529.5C 346.781,528.087 343.781,527.42 340.5,527.5C 338.585,527.784 336.919,527.451 335.5,526.5C 334.391,525.71 333.058,525.21 331.5,525C 335.612,524.527 339.612,525.027 343.5,526.5 Z"/></g>
<g><path style="opacity:0.997" fill="#e9cd85" d="M 392.5,458.5 C 393.209,459.404 394.209,459.737 395.5,459.5C 395.5,460.833 395.5,462.167 395.5,463.5C 397.5,463.5 399.5,463.5 401.5,463.5C 401.672,465.492 401.005,467.158 399.5,468.5C 400.988,470.577 402.988,471.577 405.5,471.5C 406.833,475.5 408.167,479.5 409.5,483.5C 412.167,483.5 414.833,483.5 417.5,483.5C 418.09,487.347 419.757,490.68 422.5,493.5C 424.714,491.076 425.714,491.743 425.5,495.5C 429.257,495.286 429.924,496.286 427.5,498.5C 430.809,499.715 434.142,500.715 437.5,501.5C 437.5,503.5 437.5,505.5 437.5,507.5C 439.604,507.201 441.604,507.534 443.5,508.5C 444.833,510.5 446.167,512.5 447.5,514.5C 450.032,515.119 452.365,516.119 454.5,517.5C 455.429,518.689 455.762,520.022 455.5,521.5C 456.978,521.238 458.311,521.571 459.5,522.5C 464.167,527.167 468.833,531.833 473.5,536.5C 474.689,537.429 476.022,537.762 477.5,537.5C 477.238,538.978 477.571,540.311 478.5,541.5C 481.524,543.013 484.191,545.013 486.5,547.5C 487.429,548.689 487.762,550.022 487.5,551.5C 490.167,552.167 492.833,552.833 495.5,553.5C 497.5,557.5 499.5,561.5 501.5,565.5C 502.978,565.238 504.311,565.571 505.5,566.5C 516.837,576.876 526.503,588.543 534.5,601.5C 536.987,608.465 540.987,614.465 546.5,619.5C 547.167,618.833 547.833,618.167 548.5,617.5C 549.079,620.588 550.413,623.255 552.5,625.5C 554.253,622.995 555.753,620.329 557,617.5C 557.464,618.094 557.631,618.761 557.5,619.5C 557.5,620.167 557.5,620.833 557.5,621.5C 556.596,622.209 556.263,623.209 556.5,624.5C 554.833,627.833 553.167,631.167 551.5,634.5C 551.586,633.504 551.252,632.671 550.5,632C 547.113,631.117 545.446,628.951 545.5,625.5C 544.167,625.5 542.833,625.5 541.5,625.5C 541.84,622.856 541.173,620.523 539.5,618.5C 534.372,615.708 529.039,613.375 523.5,611.5C 523.579,609.334 524.246,607.334 525.5,605.5C 525.167,604.833 524.833,604.167 524.5,603.5C 523.167,606.167 521.833,606.167 520.5,603.5C 519.833,600.167 519.167,596.833 518.5,593.5C 515.73,591.399 513.73,588.732 512.5,585.5C 511.833,586.167 511.167,586.833 510.5,587.5C 509.52,584.914 509.187,582.247 509.5,579.5C 506.833,578.833 504.167,578.167 501.5,577.5C 501.762,576.022 501.429,574.689 500.5,573.5C 497.167,570.167 493.833,566.833 490.5,563.5C 489.571,562.311 489.238,560.978 489.5,559.5C 485.5,558.167 481.5,556.833 477.5,555.5C 476.167,552.167 474.833,548.833 473.5,545.5C 471.5,545.5 469.5,545.5 467.5,545.5C 467.762,544.022 467.429,542.689 466.5,541.5C 464.5,540.167 462.5,538.833 460.5,537.5C 459.571,536.311 459.238,534.978 459.5,533.5C 457.5,533.5 455.5,533.5 453.5,533.5C 452.167,530.167 450.833,526.833 449.5,523.5C 444.555,524.324 441.888,522.324 441.5,517.5C 437.009,515.59 432.342,514.256 427.5,513.5C 426.669,508.995 424.002,505.995 419.5,504.5C 420.167,503.833 420.833,503.167 421.5,502.5C 418.914,501.52 416.247,501.187 413.5,501.5C 413.5,499.5 413.5,497.5 413.5,495.5C 412.167,495.5 410.833,495.5 409.5,495.5C 409.5,494.167 409.5,492.833 409.5,491.5C 408.167,491.5 406.833,491.5 405.5,491.5C 404.833,486.833 402.167,484.167 397.5,483.5C 397.5,481.5 397.5,479.5 397.5,477.5C 395.508,477.672 393.842,477.005 392.5,475.5C 390.483,472.45 389.483,469.117 389.5,465.5C 386.986,465.246 384.652,464.413 382.5,463C 385.821,461.396 389.154,459.896 392.5,458.5 Z"/></g>
<g><path style="opacity:0.078" fill="#dcc48e" d="M 340.5,527.5 C 343.781,527.42 346.781,528.087 349.5,529.5C 346.219,529.58 343.219,528.913 340.5,527.5 Z"/></g>
<g><path style="opacity:0.843" fill="#dec38e" d="M 350.5,529.5 C 353.152,529.41 355.485,530.076 357.5,531.5C 354.848,531.59 352.515,530.924 350.5,529.5 Z"/></g>
<g><path style="opacity:0.008" fill="#d8b971" d="M 677.5,529.5 C 679.337,529.639 679.67,530.306 678.5,531.5C 677.702,531.043 677.369,530.376 677.5,529.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d8bc71" d="M 669.5,533.5 C 671.337,533.639 671.67,534.306 670.5,535.5C 669.702,535.043 669.369,534.376 669.5,533.5 Z"/></g>
<g><path style="opacity:0.012" fill="#d9be79" d="M 656.5,534.5 C 657.833,535.167 657.833,535.167 656.5,534.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d5b96f" d="M 381.5,539.5 C 381.361,541.337 380.694,541.67 379.5,540.5C 379.957,539.702 380.624,539.369 381.5,539.5 Z"/></g>
<g><path style="opacity:0.004" fill="#d4b771" d="M 411.5,557.5 C 413.337,557.639 413.67,558.306 412.5,559.5C 411.702,559.043 411.369,558.376 411.5,557.5 Z"/></g>
<g><path style="opacity:0.965" fill="#d6ac4c" d="M 423.5,562.5 C 422.738,560.738 421.404,559.738 419.5,559.5C 418.71,558.206 417.71,557.039 416.5,556C 419.824,557.186 422.824,559.186 425.5,562C 424.906,562.464 424.239,562.631 423.5,562.5 Z"/></g>
<g><path style="opacity:0.835" fill="#dfc895" d="M 419.5,559.5 C 421.404,559.738 422.738,560.738 423.5,562.5C 421.596,562.262 420.262,561.262 419.5,559.5 Z"/></g>
<g><path style="opacity:0.71" fill="#ddc48f" d="M 428.5,567.5 C 430.027,567.427 431.027,568.094 431.5,569.5C 429.973,569.573 428.973,568.906 428.5,567.5 Z"/></g>
<g><path style="opacity:0.98" fill="#d6ad4a" d="M 434.5,572.5 C 433.833,571.167 432.833,570.167 431.5,569.5C 431.027,568.094 430.027,567.427 428.5,567.5C 428.5,567.167 428.5,566.833 428.5,566.5C 427.031,564.895 427.365,564.395 429.5,565C 431.833,567.333 434.167,569.667 436.5,572C 435.906,572.464 435.239,572.631 434.5,572.5 Z"/></g>
<g><path style="opacity:0.004" fill="#dbbf81" d="M 431.5,569.5 C 432.833,570.167 433.833,571.167 434.5,572.5C 432.121,573.567 431.121,572.567 431.5,569.5 Z"/></g>
<g><path style="opacity:0.997" fill="#dbba6d" d="M 542.5,666.5 C 542.5,667.833 542.5,669.167 542.5,670.5C 541.529,675.427 540.195,680.594 538.5,686C 538.833,686.333 539.167,686.667 539.5,687C 538.915,688.302 538.249,689.469 537.5,690.5C 537.66,688.801 537.494,687.134 537,685.5C 536.722,686.416 536.222,687.082 535.5,687.5C 535.799,685.396 535.466,683.396 534.5,681.5C 532.286,683.924 531.286,683.257 531.5,679.5C 528.102,679.82 524.768,679.487 521.5,678.5C 523.534,676.401 523.868,674.068 522.5,671.5C 521.833,672.167 521.167,672.833 520.5,673.5C 518.477,671.827 516.144,671.16 513.5,671.5C 513.5,668.167 513.5,664.833 513.5,661.5C 511.508,661.328 509.842,661.995 508.5,663.5C 507.266,661.602 507.599,659.935 509.5,658.5C 505.833,654.833 502.167,651.167 498.5,647.5C 497.19,643.243 495.523,639.243 493.5,635.5C 492.167,635.5 490.833,635.5 489.5,635.5C 488.642,628.451 485.642,622.451 480.5,617.5C 480.169,610.15 476.836,604.817 470.5,601.5C 468.256,597.686 466.589,593.686 465.5,589.5C 464.167,589.5 462.833,589.5 461.5,589.5C 461.5,587.5 461.5,585.5 461.5,583.5C 460.022,583.762 458.689,583.429 457.5,582.5C 455.792,580.457 453.792,578.79 451.5,577.5C 450.167,578.167 448.833,578.833 447.5,579.5C 445.666,578.246 443.666,577.579 441.5,577.5C 441.5,578.5 441.5,579.5 441.5,580.5C 438.823,578.155 436.49,575.488 434.5,572.5C 435.239,572.631 435.906,572.464 436.5,572C 434.167,569.667 431.833,567.333 429.5,565C 427.365,564.395 427.031,564.895 428.5,566.5C 426.251,565.92 424.585,564.587 423.5,562.5C 424.239,562.631 424.906,562.464 425.5,562C 422.824,559.186 419.824,557.186 416.5,556C 417.71,557.039 418.71,558.206 419.5,559.5C 408.023,550.76 395.357,544.093 381.5,539.5C 378.5,538.167 375.5,536.833 372.5,535.5C 373.873,535.657 375.207,535.49 376.5,535C 375.978,534.439 375.645,533.772 375.5,533C 377.518,530.482 380.185,528.982 383.5,528.5C 377.844,524.004 371.844,520.004 365.5,516.5C 367.807,514.672 367.474,513.006 364.5,511.5C 363.672,512.415 362.672,513.081 361.5,513.5C 359.109,512.809 359.109,511.809 361.5,510.5C 358.412,509.921 355.745,508.587 353.5,506.5C 354.689,505.571 356.022,505.238 357.5,505.5C 357.762,504.022 357.429,502.689 356.5,501.5C 354.5,502.833 352.5,504.167 350.5,505.5C 346.726,502.448 344.726,498.448 344.5,493.5C 343.833,494.833 343.167,496.167 342.5,497.5C 340.588,495.343 338.921,493.009 337.5,490.5C 339.5,489.833 341.5,489.167 343.5,488.5C 342.012,486.423 340.012,485.423 337.5,485.5C 337.5,482.833 337.5,480.167 337.5,477.5C 339.492,477.328 341.158,477.995 342.5,479.5C 343.429,478.311 343.762,476.978 343.5,475.5C 345.492,475.328 347.158,475.995 348.5,477.5C 349.868,480.068 349.534,482.401 347.5,484.5C 350.732,485.73 353.399,487.73 355.5,490.5C 353.995,491.842 353.328,493.508 353.5,495.5C 354.833,495.5 356.167,495.5 357.5,495.5C 357.286,499.257 358.286,499.924 360.5,497.5C 362.305,499.903 364.638,501.57 367.5,502.5C 366.167,503.167 364.833,503.833 363.5,504.5C 364.5,505.5 365.5,506.5 366.5,507.5C 368.328,505.193 369.994,505.526 371.5,508.5C 370.585,509.328 369.919,510.328 369.5,511.5C 370.191,513.891 371.191,513.891 372.5,511.5C 375.475,514.82 379.142,516.82 383.5,517.5C 383.5,518.833 383.5,520.167 383.5,521.5C 385.604,521.201 387.604,521.534 389.5,522.5C 387.599,523.935 387.266,525.602 388.5,527.5C 389.842,525.995 391.508,525.328 393.5,525.5C 393.5,526.833 393.5,528.167 393.5,529.5C 395.666,529.421 397.666,528.754 399.5,527.5C 402.463,529.461 405.129,531.794 407.5,534.5C 406.833,535.167 406.167,535.833 405.5,536.5C 408.032,537.119 410.365,538.119 412.5,539.5C 413.167,538.833 413.833,538.167 414.5,537.5C 415.167,539.5 415.833,541.5 416.5,543.5C 417.328,542.585 418.328,541.919 419.5,541.5C 427.995,545.664 435.661,550.998 442.5,557.5C 443.167,556.833 443.833,556.167 444.5,555.5C 446.225,558.674 447.558,562.007 448.5,565.5C 449.167,564.833 449.833,564.167 450.5,563.5C 452.001,564.752 453.668,565.752 455.5,566.5C 458.167,569.833 460.833,573.167 463.5,576.5C 464.689,577.429 466.022,577.762 467.5,577.5C 467.5,578.833 467.5,580.167 467.5,581.5C 468.833,581.5 470.167,581.5 471.5,581.5C 471.238,582.978 471.571,584.311 472.5,585.5C 475.474,587.006 475.807,588.672 473.5,590.5C 475.398,591.734 477.065,591.401 478.5,589.5C 480.478,594.44 482.811,599.106 485.5,603.5C 486.833,603.5 488.167,603.5 489.5,603.5C 489.5,605.5 489.5,607.5 489.5,609.5C 493.795,609.279 494.462,610.612 491.5,613.5C 493.126,616.128 495.126,618.461 497.5,620.5C 496.833,621.167 496.167,621.833 495.5,622.5C 496.833,623.833 498.167,625.167 499.5,626.5C 498.833,627.167 498.167,627.833 497.5,628.5C 500.167,629.167 502.833,629.833 505.5,630.5C 503.076,632.714 503.743,633.714 507.5,633.5C 507.917,636.343 508.917,639.01 510.5,641.5C 511.842,643.005 513.508,643.672 515.5,643.5C 515.5,644.833 515.5,646.167 515.5,647.5C 519.257,647.286 519.924,648.286 517.5,650.5C 519.108,654.043 521.442,657.043 524.5,659.5C 525.167,658.833 525.833,658.167 526.5,657.5C 527.079,660.588 528.413,663.255 530.5,665.5C 532.714,663.076 533.714,663.743 533.5,667.5C 536.167,666.833 538.833,666.167 541.5,665.5C 542.003,660.5 542.336,660.833 542.5,666.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d8b768" d="M 535.5,687.5 C 535.478,692.272 534.811,696.939 533.5,701.5C 532.414,701.38 531.747,700.713 531.5,699.5C 532.167,698.167 532.833,696.833 533.5,695.5C 533.167,694.833 532.833,694.167 532.5,693.5C 531.672,694.415 530.672,695.081 529.5,695.5C 527.545,694.547 525.878,693.213 524.5,691.5C 523.833,692.167 523.167,692.833 522.5,693.5C 521.833,690.833 521.167,688.167 520.5,685.5C 519.833,686.167 519.167,686.833 518.5,687.5C 517.52,684.914 517.187,682.247 517.5,679.5C 513.678,679.351 511.345,677.351 510.5,673.5C 509.833,674.167 509.167,674.833 508.5,675.5C 506.833,673.833 505.167,672.167 503.5,670.5C 505.401,669.065 505.734,667.398 504.5,665.5C 500.685,671.165 499.018,670.498 499.5,663.5C 504.833,662.833 504.833,662.167 499.5,661.5C 498.356,657.989 496.689,654.656 494.5,651.5C 493.833,652.167 493.167,652.833 492.5,653.5C 489.066,650.524 486.732,646.857 485.5,642.5C 486.167,641.833 486.833,641.167 487.5,640.5C 486.167,639.833 484.833,639.167 483.5,638.5C 484.167,637.833 484.833,637.167 485.5,636.5C 480.965,633.385 478.631,629.051 478.5,623.5C 476.671,621.844 475.337,619.844 474.5,617.5C 473.833,618.167 473.167,618.833 472.5,619.5C 471.732,614.38 470.066,609.713 467.5,605.5C 464.927,605.852 462.594,605.352 460.5,604C 461.059,603.275 461.392,602.442 461.5,601.5C 460.246,599.666 459.579,597.666 459.5,595.5C 456.715,594.916 455.048,595.916 454.5,598.5C 450.164,592.49 445.83,586.49 441.5,580.5C 441.5,579.5 441.5,578.5 441.5,577.5C 443.666,577.579 445.666,578.246 447.5,579.5C 448.833,578.833 450.167,578.167 451.5,577.5C 453.792,578.79 455.792,580.457 457.5,582.5C 458.689,583.429 460.022,583.762 461.5,583.5C 461.5,585.5 461.5,587.5 461.5,589.5C 462.833,589.5 464.167,589.5 465.5,589.5C 466.589,593.686 468.256,597.686 470.5,601.5C 476.836,604.817 480.169,610.15 480.5,617.5C 485.642,622.451 488.642,628.451 489.5,635.5C 490.833,635.5 492.167,635.5 493.5,635.5C 495.523,639.243 497.19,643.243 498.5,647.5C 502.167,651.167 505.833,654.833 509.5,658.5C 507.599,659.935 507.266,661.602 508.5,663.5C 509.842,661.995 511.508,661.328 513.5,661.5C 513.5,664.833 513.5,668.167 513.5,671.5C 516.144,671.16 518.477,671.827 520.5,673.5C 521.167,672.833 521.833,672.167 522.5,671.5C 523.868,674.068 523.534,676.401 521.5,678.5C 524.768,679.487 528.102,679.82 531.5,679.5C 531.286,683.257 532.286,683.924 534.5,681.5C 535.466,683.396 535.799,685.396 535.5,687.5 Z"/></g>
<g><path style="opacity:0.012" fill="#e1c786" d="M 557.5,621.5 C 559.337,621.639 559.67,622.306 558.5,623.5C 557.702,623.043 557.369,622.376 557.5,621.5 Z"/></g>
<g><path style="opacity:0.008" fill="#dfc782" d="M 556.5,624.5 C 557.833,625.167 557.833,625.167 556.5,624.5 Z"/></g>
<g><path style="opacity:0.008" fill="#d0b269" d="M 463.5,627.5 C 465.337,627.639 465.67,628.306 464.5,629.5C 463.702,629.043 463.369,628.376 463.5,627.5 Z"/></g>
<g><path style="opacity:0.863" fill="#dcc085" d="M 467.5,625.5 C 469.293,627.426 470.293,629.759 470.5,632.5C 469.782,630.754 468.782,630.088 467.5,630.5C 468.052,628.997 468.052,627.331 467.5,625.5 Z"/></g>
<g><path style="opacity:0.996" fill="#cca243" d="M 478.5,651.5 C 479.417,654.005 479.417,656.338 478.5,658.5C 478.672,657.508 478.338,656.842 477.5,656.5C 477.59,653.848 476.924,651.515 475.5,649.5C 475.5,649.167 475.5,648.833 475.5,648.5C 475.253,645.146 474.253,642.146 472.5,639.5C 472.343,638.127 472.51,636.793 473,635.5C 475.144,640.748 476.977,646.081 478.5,651.5 Z"/></g>
<g><path style="opacity:0.788" fill="#ddc38b" d="M 472.5,639.5 C 474.253,642.146 475.253,645.146 475.5,648.5C 473.747,645.854 472.747,642.854 472.5,639.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d5b365" d="M 533.5,701.5 C 533.167,704.833 532.833,708.167 532.5,711.5C 531.834,714.028 531.168,716.694 530.5,719.5C 529.833,717.5 529.167,715.5 528.5,713.5C 527.833,714.167 527.167,714.833 526.5,715.5C 524.5,712.833 522.5,710.167 520.5,707.5C 519.833,708.167 519.167,708.833 518.5,709.5C 517.434,701.609 513.767,695.275 507.5,690.5C 509.401,689.065 509.734,687.398 508.5,685.5C 507.833,686.167 507.167,686.833 506.5,687.5C 503.353,684.532 500.686,681.198 498.5,677.5C 497.5,675.5 496.5,673.5 495.5,671.5C 495.919,670.328 496.585,669.328 497.5,668.5C 496.5,667.5 495.5,666.5 494.5,665.5C 493.833,666.833 493.167,668.167 492.5,669.5C 491.663,667.156 490.329,665.156 488.5,663.5C 488.68,656.361 485.347,652.361 478.5,651.5C 476.977,646.081 475.144,640.748 473,635.5C 472.51,636.793 472.343,638.127 472.5,639.5C 471.388,637.401 470.721,635.067 470.5,632.5C 470.293,629.759 469.293,627.426 467.5,625.5C 463.442,616.383 459.108,607.383 454.5,598.5C 455.048,595.916 456.715,594.916 459.5,595.5C 459.579,597.666 460.246,599.666 461.5,601.5C 461.392,602.442 461.059,603.275 460.5,604C 462.594,605.352 464.927,605.852 467.5,605.5C 470.066,609.713 471.732,614.38 472.5,619.5C 473.167,618.833 473.833,618.167 474.5,617.5C 475.337,619.844 476.671,621.844 478.5,623.5C 478.631,629.051 480.965,633.385 485.5,636.5C 484.833,637.167 484.167,637.833 483.5,638.5C 484.833,639.167 486.167,639.833 487.5,640.5C 486.833,641.167 486.167,641.833 485.5,642.5C 486.732,646.857 489.066,650.524 492.5,653.5C 493.167,652.833 493.833,652.167 494.5,651.5C 496.689,654.656 498.356,657.989 499.5,661.5C 504.833,662.167 504.833,662.833 499.5,663.5C 499.018,670.498 500.685,671.165 504.5,665.5C 505.734,667.398 505.401,669.065 503.5,670.5C 505.167,672.167 506.833,673.833 508.5,675.5C 509.167,674.833 509.833,674.167 510.5,673.5C 511.345,677.351 513.678,679.351 517.5,679.5C 517.187,682.247 517.52,684.914 518.5,687.5C 519.167,686.833 519.833,686.167 520.5,685.5C 521.167,688.167 521.833,690.833 522.5,693.5C 523.167,692.833 523.833,692.167 524.5,691.5C 525.878,693.213 527.545,694.547 529.5,695.5C 530.672,695.081 531.672,694.415 532.5,693.5C 532.833,694.167 533.167,694.833 533.5,695.5C 532.833,696.833 532.167,698.167 531.5,699.5C 531.747,700.713 532.414,701.38 533.5,701.5 Z"/></g>
<g><path style="opacity:0.933" fill="#d7bb81" d="M 475.5,649.5 C 476.924,651.515 477.59,653.848 477.5,656.5C 476.699,654.256 475.366,652.256 473.5,650.5C 473.957,649.702 474.624,649.369 475.5,649.5 Z"/></g>
<g><path style="opacity:0.208" fill="#dcc594" d="M 477.5,656.5 C 478.338,656.842 478.672,657.508 478.5,658.5C 478.328,659.492 478.662,660.158 479.5,660.5C 479.5,661.833 479.5,663.167 479.5,664.5C 477.96,662.162 477.294,659.495 477.5,656.5 Z"/></g>
<g><path style="opacity:0.992" fill="#cfa44d" d="M 481.5,670.5 C 479.919,668.858 479.253,666.858 479.5,664.5C 479.5,663.167 479.5,661.833 479.5,660.5C 481.078,662.602 482.078,665.602 482.5,669.5C 482.333,670.167 482.167,670.833 482,671.5C 481.601,671.272 481.435,670.938 481.5,670.5 Z"/></g>
<g><path style="opacity:0.008" fill="#d1af6a" d="M 542.5,670.5 C 543.833,671.167 543.833,671.167 542.5,670.5 Z"/></g>
<g><path style="opacity:0.992" fill="#cea759" d="M 486.5,690.5 C 488.132,697.42 488.965,704.42 489,711.5C 488.768,710.263 488.268,709.263 487.5,708.5C 486.597,703.527 485.597,698.527 484.5,693.5C 484.608,692.558 484.941,691.725 485.5,691C 484.074,688.955 483.074,686.788 482.5,684.5C 482.5,682.833 482.5,681.167 482.5,679.5C 482.338,677.473 482.505,675.473 483,673.5C 484.617,679.086 485.784,684.753 486.5,690.5 Z"/></g>
<g><path style="opacity:0.008" fill="#cdac63" d="M 482.5,684.5 C 481.791,685.404 480.791,685.737 479.5,685.5C 479.67,680.725 480.67,680.392 482.5,684.5 Z"/></g>
<g><path style="opacity:0.996" fill="#d2af61" d="M 478.5,651.5 C 485.347,652.361 488.68,656.361 488.5,663.5C 490.329,665.156 491.663,667.156 492.5,669.5C 493.167,668.167 493.833,666.833 494.5,665.5C 495.5,666.5 496.5,667.5 497.5,668.5C 496.585,669.328 495.919,670.328 495.5,671.5C 496.5,673.5 497.5,675.5 498.5,677.5C 500.686,681.198 503.353,684.532 506.5,687.5C 507.167,686.833 507.833,686.167 508.5,685.5C 509.734,687.398 509.401,689.065 507.5,690.5C 513.767,695.275 517.434,701.609 518.5,709.5C 519.167,708.833 519.833,708.167 520.5,707.5C 522.5,710.167 524.5,712.833 526.5,715.5C 527.167,714.833 527.833,714.167 528.5,713.5C 529.167,715.5 529.833,717.5 530.5,719.5C 531.168,716.694 531.834,714.028 532.5,711.5C 532.328,712.492 532.662,713.158 533.5,713.5C 533.5,714.167 533.5,714.833 533.5,715.5C 533.802,718.059 533.468,720.393 532.5,722.5C 532.167,722.5 531.833,722.5 531.5,722.5C 529.49,729.918 528.657,737.585 529,745.5C 529.186,742.964 529.686,740.631 530.5,738.5C 530.414,739.496 530.748,740.329 531.5,741C 530.374,745.909 529.374,750.742 528.5,755.5C 528.664,752.813 528.497,750.146 528,747.5C 526.892,751.086 526.392,754.753 526.5,758.5C 524.238,760.047 522.238,759.714 520.5,757.5C 519.833,754.833 519.167,752.167 518.5,749.5C 516.672,751.807 515.006,751.474 513.5,748.5C 514.689,747.571 516.022,747.238 517.5,747.5C 517.5,744.833 517.5,742.167 517.5,739.5C 516.167,739.5 514.833,739.5 513.5,739.5C 513.813,736.753 513.48,734.086 512.5,731.5C 511.833,732.167 511.167,732.833 510.5,733.5C 509.158,731.995 507.492,731.328 505.5,731.5C 505.5,726.833 505.5,722.167 505.5,717.5C 501.743,717.714 501.076,716.714 503.5,714.5C 502.311,713.571 500.978,713.238 499.5,713.5C 499.16,710.856 499.827,708.523 501.5,706.5C 498.833,703.167 496.167,699.833 493.5,696.5C 494.167,695.833 494.833,695.167 495.5,694.5C 492.858,691.663 489.858,690.33 486.5,690.5C 485.784,684.753 484.617,679.086 483,673.5C 482.505,675.473 482.338,677.473 482.5,679.5C 481.683,677.169 481.016,674.669 480.5,672C 480.57,671.235 480.903,670.735 481.5,670.5C 481.435,670.938 481.601,671.272 482,671.5C 482.167,670.833 482.333,670.167 482.5,669.5C 482.078,665.602 481.078,662.602 479.5,660.5C 478.662,660.158 478.328,659.492 478.5,658.5C 479.417,656.338 479.417,654.005 478.5,651.5 Z"/></g>
<g><path style="opacity:0.008" fill="#caaa62" d="M 479.5,687.5 C 481.337,687.639 481.67,688.306 480.5,689.5C 479.702,689.043 479.369,688.376 479.5,687.5 Z"/></g>
<g><path style="opacity:0.965" fill="#d1a84c" d="M 537.5,690.5 C 537.5,690.833 537.5,691.167 537.5,691.5C 535.53,698.588 534.197,705.921 533.5,713.5C 532.662,713.158 532.328,712.492 532.5,711.5C 532.833,708.167 533.167,704.833 533.5,701.5C 534.811,696.939 535.478,692.272 535.5,687.5C 536.222,687.082 536.722,686.416 537,685.5C 537.494,687.134 537.66,688.801 537.5,690.5 Z"/></g>
<g><path style="opacity:0.008" fill="#c7aa60" d="M 479.5,699.5 C 481.337,699.639 481.67,700.306 480.5,701.5C 479.702,701.043 479.369,700.376 479.5,699.5 Z"/></g>
<g><path style="opacity:0.769" fill="#dec694" d="M 537.5,691.5 C 536.795,699.732 535.461,707.732 533.5,715.5C 533.5,714.833 533.5,714.167 533.5,713.5C 534.197,705.921 535.53,698.588 537.5,691.5 Z"/></g>
<g><path style="opacity:0.004" fill="#68665d" d="M 171.5,709.5 C 173.337,709.639 173.67,710.306 172.5,711.5C 171.702,711.043 171.369,710.376 171.5,709.5 Z"/></g>
<g><path style="opacity:0.004" fill="#caa85e" d="M 487.5,722.5 C 488.833,723.167 488.833,723.167 487.5,722.5 Z"/></g>
<g><path style="opacity:0.008" fill="#c9aa5f" d="M 487.5,725.5 C 488.525,725.897 488.692,726.563 488,727.5C 487.536,726.906 487.369,726.239 487.5,725.5 Z"/></g>
<g><path style="opacity:0.686" fill="#dbc083" d="M 531.5,722.5 C 531.833,722.5 532.167,722.5 532.5,722.5C 532.473,728.051 531.806,733.384 530.5,738.5C 530.687,733.155 531.02,727.822 531.5,722.5 Z"/></g>
<g><path style="opacity:0.984" fill="#caa151" d="M 494.5,747.5 C 494.768,749.099 494.434,750.432 493.5,751.5C 493.461,747.267 492.795,743.267 491.5,739.5C 491.167,739.5 490.833,739.5 490.5,739.5C 490.223,736.552 490.556,733.719 491.5,731C 489.656,728.196 488.989,725.03 489.5,721.5C 489.336,718.813 489.503,716.146 490,713.5C 491.829,724.796 493.329,736.13 494.5,747.5 Z"/></g>
<g><path style="opacity:0.98" fill="#cca244" d="M 531.5,722.5 C 531.02,727.822 530.687,733.155 530.5,738.5C 529.686,740.631 529.186,742.964 529,745.5C 528.657,737.585 529.49,729.918 531.5,722.5 Z"/></g>
<g><path style="opacity:0.996" fill="#ceaa5c" d="M 526.5,758.5 C 525.701,761.43 525.368,764.43 525.5,767.5C 523.508,767.672 521.842,767.005 520.5,765.5C 519.833,767.5 519.167,769.5 518.5,771.5C 517.52,768.914 517.187,766.247 517.5,763.5C 514.833,763.5 512.167,763.5 509.5,763.5C 509.243,760.068 508.576,756.734 507.5,753.5C 506.022,753.762 504.689,753.429 503.5,752.5C 505.005,751.158 505.672,749.492 505.5,747.5C 504.167,747.5 502.833,747.5 501.5,747.5C 499.421,737.221 497.088,737.221 494.5,747.5C 493.329,736.13 491.829,724.796 490,713.5C 489.503,716.146 489.336,718.813 489.5,721.5C 488.105,717.409 487.438,713.076 487.5,708.5C 488.268,709.263 488.768,710.263 489,711.5C 488.965,704.42 488.132,697.42 486.5,690.5C 489.858,690.33 492.858,691.663 495.5,694.5C 494.833,695.167 494.167,695.833 493.5,696.5C 496.167,699.833 498.833,703.167 501.5,706.5C 499.827,708.523 499.16,710.856 499.5,713.5C 500.978,713.238 502.311,713.571 503.5,714.5C 501.076,716.714 501.743,717.714 505.5,717.5C 505.5,722.167 505.5,726.833 505.5,731.5C 507.492,731.328 509.158,731.995 510.5,733.5C 511.167,732.833 511.833,732.167 512.5,731.5C 513.48,734.086 513.813,736.753 513.5,739.5C 514.833,739.5 516.167,739.5 517.5,739.5C 517.5,742.167 517.5,744.833 517.5,747.5C 516.022,747.238 514.689,747.571 513.5,748.5C 515.006,751.474 516.672,751.807 518.5,749.5C 519.167,752.167 519.833,754.833 520.5,757.5C 522.238,759.714 524.238,760.047 526.5,758.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c8a55b" d="M 490.5,739.5 C 489.833,740.167 489.833,740.167 490.5,739.5 Z"/></g>
<g><path style="opacity:0.294" fill="#d6bc8d" d="M 491.5,739.5 C 492.795,743.267 493.461,747.267 493.5,751.5C 493.5,752.833 493.5,754.167 493.5,755.5C 492.043,750.402 491.376,745.069 491.5,739.5 Z"/></g>
<g><path style="opacity:0.402" fill="#dbc190" d="M 528.5,756.5 C 528.404,762.373 527.737,768.04 526.5,773.5C 526.216,767.583 526.883,761.916 528.5,756.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c5a65d" d="M 491.5,762.5 C 492.833,763.167 492.833,763.167 491.5,762.5 Z"/></g>
<g><path style="opacity:0.122" fill="#d5ba8d" d="M 493.5,755.5 C 493.833,755.5 494.167,755.5 494.5,755.5C 494.342,758.902 494.676,762.236 495.5,765.5C 493.598,762.663 492.931,759.329 493.5,755.5 Z"/></g>
<g><path style="opacity:0.988" fill="#c29335" d="M 494.5,755.5 C 496.428,760.767 496.761,766.1 495.5,771.5C 495.5,769.833 495.5,768.167 495.5,766.5C 495.5,766.167 495.5,765.833 495.5,765.5C 494.676,762.236 494.342,758.902 494.5,755.5 Z"/></g>
<g><path style="opacity:0.997" fill="#c7a255" d="M 519.5,830.5 C 519.5,830.833 519.5,831.167 519.5,831.5C 519.5,834.5 519.5,837.5 519.5,840.5C 519.5,840.833 519.5,841.167 519.5,841.5C 518.202,847.121 517.202,852.788 516.5,858.5C 514.597,866.228 513.264,875.395 512.5,886C 512.508,887.707 512.842,889.207 513.5,890.5C 513.5,890.833 513.5,891.167 513.5,891.5C 513.672,892.492 513.338,893.158 512.5,893.5C 512.167,893.5 511.833,893.5 511.5,893.5C 509.869,885.194 508.202,877.528 506.5,870.5C 505.596,869.791 505.263,868.791 505.5,867.5C 506.156,866.378 506.489,865.045 506.5,863.5C 505.639,849.681 503.972,836.681 501.5,824.5C 500.508,824.672 499.842,824.338 499.5,823.5C 500.833,821.5 500.833,819.5 499.5,817.5C 498.271,813.633 498.271,809.8 499.5,806C 497.638,802.851 496.971,799.351 497.5,795.5C 497.227,788.496 496.894,781.496 496.5,774.5C 497.209,773.596 498.209,773.263 499.5,773.5C 499.5,772.167 499.5,770.833 499.5,769.5C 500.833,769.5 502.167,769.5 503.5,769.5C 503.073,772.788 503.74,775.788 505.5,778.5C 504.311,779.429 502.978,779.762 501.5,779.5C 501.201,781.604 501.534,783.604 502.5,785.5C 503.429,784.311 503.762,782.978 503.5,781.5C 504.978,781.238 506.311,781.571 507.5,782.5C 505.995,783.842 505.328,785.508 505.5,787.5C 506.833,787.5 508.167,787.5 509.5,787.5C 509.927,790.788 509.26,793.788 507.5,796.5C 509.5,797.167 511.5,797.833 513.5,798.5C 512.167,799.167 510.833,799.833 509.5,800.5C 511.37,805.261 512.037,810.261 511.5,815.5C 512.833,815.5 514.167,815.5 515.5,815.5C 515.672,817.492 515.005,819.158 513.5,820.5C 516.167,821.833 516.167,823.167 513.5,824.5C 514.167,825.167 514.833,825.833 515.5,826.5C 512.833,828.5 512.833,830.5 515.5,832.5C 514.311,833.429 512.978,833.762 511.5,833.5C 511.5,835.5 511.5,837.5 511.5,839.5C 512.833,839.5 514.167,839.5 515.5,839.5C 515.238,840.978 515.571,842.311 516.5,843.5C 517.66,838.223 518.493,832.889 519,827.5C 519.483,828.448 519.649,829.448 519.5,830.5 Z"/></g>
<g><path style="opacity:0.996" fill="#cba759" d="M 526.5,758.5 C 526.392,754.753 526.892,751.086 528,747.5C 528.497,750.146 528.664,752.813 528.5,755.5C 528.5,755.833 528.5,756.167 528.5,756.5C 526.883,761.916 526.216,767.583 526.5,773.5C 526.5,774.167 526.5,774.833 526.5,775.5C 524.922,780.583 524.255,785.916 524.5,791.5C 524.586,797.736 523.919,804.07 522.5,810.5C 522.665,807.15 522.498,803.817 522,800.5C 520.789,808.821 520.122,817.155 520,825.5C 520.278,824.584 520.778,823.918 521.5,823.5C 521.662,825.527 521.495,827.527 521,829.5C 520.617,830.056 520.117,830.389 519.5,830.5C 519.649,829.448 519.483,828.448 519,827.5C 518.493,832.889 517.66,838.223 516.5,843.5C 515.571,842.311 515.238,840.978 515.5,839.5C 514.167,839.5 512.833,839.5 511.5,839.5C 511.5,837.5 511.5,835.5 511.5,833.5C 512.978,833.762 514.311,833.429 515.5,832.5C 512.833,830.5 512.833,828.5 515.5,826.5C 514.833,825.833 514.167,825.167 513.5,824.5C 516.167,823.167 516.167,821.833 513.5,820.5C 515.005,819.158 515.672,817.492 515.5,815.5C 514.167,815.5 512.833,815.5 511.5,815.5C 512.037,810.261 511.37,805.261 509.5,800.5C 510.833,799.833 512.167,799.167 513.5,798.5C 511.5,797.833 509.5,797.167 507.5,796.5C 509.26,793.788 509.927,790.788 509.5,787.5C 508.167,787.5 506.833,787.5 505.5,787.5C 505.328,785.508 505.995,783.842 507.5,782.5C 506.311,781.571 504.978,781.238 503.5,781.5C 503.762,782.978 503.429,784.311 502.5,785.5C 501.534,783.604 501.201,781.604 501.5,779.5C 502.978,779.762 504.311,779.429 505.5,778.5C 503.74,775.788 503.073,772.788 503.5,769.5C 502.167,769.5 500.833,769.5 499.5,769.5C 499.5,770.833 499.5,772.167 499.5,773.5C 498.209,773.263 497.209,773.596 496.5,774.5C 495.596,773.791 495.263,772.791 495.5,771.5C 496.761,766.1 496.428,760.767 494.5,755.5C 494.167,755.5 493.833,755.5 493.5,755.5C 493.5,754.167 493.5,752.833 493.5,751.5C 494.434,750.432 494.768,749.099 494.5,747.5C 497.088,737.221 499.421,737.221 501.5,747.5C 502.833,747.5 504.167,747.5 505.5,747.5C 505.672,749.492 505.005,751.158 503.5,752.5C 504.689,753.429 506.022,753.762 507.5,753.5C 508.576,756.734 509.243,760.068 509.5,763.5C 512.167,763.5 514.833,763.5 517.5,763.5C 517.187,766.247 517.52,768.914 518.5,771.5C 519.167,769.5 519.833,767.5 520.5,765.5C 521.842,767.005 523.508,767.672 525.5,767.5C 525.368,764.43 525.701,761.43 526.5,758.5 Z"/></g>
<g><path style="opacity:0.137" fill="#d8bd8c" d="M 495.5,766.5 C 495.5,768.167 495.5,769.833 495.5,771.5C 495.263,772.791 495.596,773.791 496.5,774.5C 496.894,781.496 497.227,788.496 497.5,795.5C 496.215,787.516 495.215,779.349 494.5,771C 494.508,769.293 494.842,767.793 495.5,766.5 Z"/></g>
<g><path style="opacity:0.012" fill="#d6bb88" d="M 526.5,775.5 C 526.232,778.119 526.565,780.619 527.5,783C 525.959,785.677 524.959,788.51 524.5,791.5C 524.255,785.916 524.922,780.583 526.5,775.5 Z"/></g>
<g><path style="opacity:0.008" fill="#c5a45a" d="M 495.5,801.5 C 496.525,801.897 496.692,802.563 496,803.5C 495.536,802.906 495.369,802.239 495.5,801.5 Z"/></g>
<g><path style="opacity:0.982" fill="#c3993f" d="M 522.5,810.5 C 522.5,810.833 522.5,811.167 522.5,811.5C 521.527,813.948 521.194,816.615 521.5,819.5C 521.5,820.833 521.5,822.167 521.5,823.5C 520.778,823.918 520.278,824.584 520,825.5C 520.122,817.155 520.789,808.821 522,800.5C 522.498,803.817 522.665,807.15 522.5,810.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c9ac6f" d="M 499.5,817.5 C 500.833,819.5 500.833,821.5 499.5,823.5C 499.5,822.167 499.5,820.833 499.5,819.5C 494.167,818.833 494.167,818.167 499.5,817.5 Z"/></g>
<g><path style="opacity:0.133" fill="#d5bd88" d="M 522.5,811.5 C 523.043,811.56 523.376,811.893 523.5,812.5C 522.933,814.982 522.266,817.316 521.5,819.5C 521.194,816.615 521.527,813.948 522.5,811.5 Z"/></g>
<g><path style="opacity:0.988" fill="#be9239" d="M 505.5,867.5 C 504.167,853.5 502.833,839.5 501.5,825.5C 501.5,825.167 501.5,824.833 501.5,824.5C 503.972,836.681 505.639,849.681 506.5,863.5C 506.489,865.045 506.156,866.378 505.5,867.5 Z"/></g>
<g><path style="opacity:0.37" fill="#d1b888" d="M 519.5,831.5 C 520.239,831.369 520.906,831.536 521.5,832C 520.872,834.939 520.205,837.772 519.5,840.5C 519.5,837.5 519.5,834.5 519.5,831.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c0a05b" d="M 501.5,835.5 C 501.5,836.833 501.5,838.167 501.5,839.5C 500.414,839.38 499.747,838.713 499.5,837.5C 499.747,836.287 500.414,835.62 501.5,835.5 Z"/></g>
<g><path style="opacity:0.443" fill="#d2b88a" d="M 501.5,825.5 C 502.833,839.5 504.167,853.5 505.5,867.5C 505.263,868.791 505.596,869.791 506.5,870.5C 506.5,873.5 506.5,876.5 506.5,879.5C 505.549,877.597 504.549,875.597 503.5,873.5C 504.015,871.364 504.349,869.197 504.5,867C 503.466,857.827 502.466,848.66 501.5,839.5C 501.5,838.167 501.5,836.833 501.5,835.5C 500.3,832.031 500.3,828.698 501.5,825.5 Z"/></g>
<g><path style="opacity:0.004" fill="#c0a05d" d="M 499.5,840.5 C 500.833,841.167 500.833,841.167 499.5,840.5 Z"/></g>
<g><path style="opacity:0.129" fill="#d1b986" d="M 519.5,841.5 C 518.907,850.173 518.24,858.839 517.5,867.5C 516.523,864.713 516.19,861.713 516.5,858.5C 517.202,852.788 518.202,847.121 519.5,841.5 Z"/></g>
<g><path style="opacity:1" fill="#b48933" d="M 511.5,893.5 C 510.391,893.443 509.391,893.11 508.5,892.5C 508.376,887.951 507.709,883.618 506.5,879.5C 506.5,876.5 506.5,873.5 506.5,870.5C 508.202,877.528 509.869,885.194 511.5,893.5 Z"/></g>
<g><path style="opacity:0.004" fill="#5b5c5a" d="M 987.5,877.5 C 989.337,877.639 989.67,878.306 988.5,879.5C 987.702,879.043 987.369,878.376 987.5,877.5 Z"/></g>
<g><path style="opacity:1" fill="#c0994e" d="M 516.5,858.5 C 516.19,861.713 516.523,864.713 517.5,867.5C 516.494,872.928 515.494,878.262 514.5,883.5C 513.532,885.607 513.198,887.941 513.5,890.5C 512.842,889.207 512.508,887.707 512.5,886C 513.264,875.395 514.597,866.228 516.5,858.5 Z"/></g>
<g><path style="opacity:0.004" fill="#b89b61" d="M 516.5,879.5 C 517.833,880.167 517.833,880.167 516.5,879.5 Z"/></g>
<g><path style="opacity:0.592" fill="#ccb48b" d="M 506.5,879.5 C 507.709,883.618 508.376,887.951 508.5,892.5C 507.833,892.5 507.5,892.167 507.5,891.5C 506.838,887.534 506.505,883.534 506.5,879.5 Z"/></g>
<g><path style="opacity:0.624" fill="#cdb689" d="M 514.5,883.5 C 514.611,884.117 514.944,884.617 515.5,885C 514.883,887.277 514.216,889.444 513.5,891.5C 513.5,891.167 513.5,890.833 513.5,890.5C 513.198,887.941 513.532,885.607 514.5,883.5 Z"/></g>
<g><path style="opacity:0.006" fill="#b29a67" d="M 507.5,891.5 C 507.5,892.167 507.833,892.5 508.5,892.5C 509.391,893.11 510.391,893.443 511.5,893.5C 511.833,893.5 512.167,893.5 512.5,893.5C 511.348,895.688 509.848,895.688 508,893.5C 507.002,896.028 506.169,896.028 505.5,893.5C 505.747,892.287 506.414,891.62 507.5,891.5 Z"/></g>
<g><path style="opacity:0.004" fill="#5a5c58" d="M 107.5,901.5 C 109.337,901.639 109.67,902.306 108.5,903.5C 107.702,903.043 107.369,902.376 107.5,901.5 Z"/></g>
<g><path style="opacity:0.004" fill="#5b5a57" d="M 851.5,925.5 C 853.337,925.639 853.67,926.306 852.5,927.5C 851.702,927.043 851.369,926.376 851.5,925.5 Z"/></g>
<g><path style="opacity:0.004" fill="#595a57" d="M 915.5,965.5 C 917.337,965.639 917.67,966.306 916.5,967.5C 915.702,967.043 915.369,966.376 915.5,965.5 Z"/></g>
<g><path style="opacity:0.004" fill="#595a55" d="M 819.5,973.5 C 821.337,973.639 821.67,974.306 820.5,975.5C 819.702,975.043 819.369,974.376 819.5,973.5 Z"/></g>
</svg>
" + // 添加三颗星 + const starPositions = [ + {x: xPos + 15, y: centerY - 20}, // 左上 + {x: xPos - 5 , y: centerY}, // 中间 + {x: xPos + 15, y: centerY + 20} // 左下 + ]; + + starPositions.forEach(pos => { + g.append("image") + .attr("x", pos.x) + .attr("y", pos.y - starHeight/2) // 垂直居中 + .attr("width", starWidth) + .attr("height", starHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", starBase64); + }); + } + } + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + const centerY = yScale(dimension) + barHeight / 2; + + // 1. 添加维度文本标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", textX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", textX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 2. 添加图标 (在文本右侧) + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 3. 绘制条形 (在图标右侧) + g.append("rect") + .attr("x", barX) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", "url(#bar-gradient)") // 强制使用渐变 + .attr("rx", barHeight/3) // 较大的圆角半径，确保两端都是圆形 + .attr("ry", barHeight/3) + .style("stroke", getStrokeColor()) // 强制使用描边 + .style("stroke-width", 1) // 设置描边宽度 + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 新增: 为第一个条形添加星星 + addStarsToFirstBar(g, dimension, barWidth, barHeight, centerY); + + // 4. 添加数值标签 (在条形右侧) + const formattedValue = valueUnit ? + `${dataPoint[valueField]}${valueUnit}` : + `${dataPoint[valueField]}`; + + g.append("text") + .attr("x", barWidth + barValueGap) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_7.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_7.js new file mode 100644 index 0000000000000000000000000000000000000000..90b0a24dbcf9b3fb5f207c8d2d4990e54e90e8b6 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_7.js @@ -0,0 +1,410 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_7", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 - 初始值，稍后会根据标签长度调整 + const margin = { + top: 60, // 顶部留出标题空间 + right: 40, // 右侧足够显示数值 + bottom: 30, // 底部边距 + left: 80 // 左侧空间，稍后会调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + let valueUnit2 = ""; + valueUnit2 = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 如果x维度数量超过15，每增加一个x，整个图像的高度增加3% + const baseHeight = variables.height || 600; + const adjustedHeight = dimensions.length > 15 + ? baseHeight * (1 + (dimensions.length - 15) * 0.03) + : baseHeight; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 5. 计算标签宽度 ---------- + + // 序号宽度 + const rankingWidth = 25; + + // 图标尺寸 + let flagWidth = 40; + let flagHeight = 40; + const flagPadding = 7; + const labelMeasureOptions = { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }; + const annotationMeasureOptions = { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }; + + // 计算最大维度标签宽度（不包括图标和序号） + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, labelMeasureOptions).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const value = +d[valueField]; + const valueText = `${chartUtils.format.autoText(value)}${valueUnit}`; + + const textWidth = chartUtils.text.measure(null, valueText, annotationMeasureOptions).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 计算左边距，考虑序号 + 标签 + 图标之间的间距 + // 序号在最左边，然后是标签（右对齐），然后是图标 + const totalLeftPadding = rankingWidth + maxLabelWidth + flagWidth + flagPadding * 5; + margin.left = Math.max(margin.left, totalLeftPadding); + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = adjustedHeight - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) // 使用固定宽度而不是百分比 + .attr("height", adjustedHeight) + .attr("viewBox", `0 0 ${width} ${adjustedHeight}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#1d6b64" }).value; + + // 获取最大值和最小值用于颜色插值 + const minValue = d3.min(chartData, d => +d[valueField]); + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 创建颜色比例尺 - 将数值映射到颜色 + const colorScale = d3.scaleLinear() + .domain([minValue, maxValue]) + .range([colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.4 }), colorResolver.variant(primaryColor, { mode: "darker", amount: 0.4 })]); + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建标题和描述 ---------- + + // 添加图表标题（如果存在） + if (jsonData.title) { + svg.append("text") + .attr("x", width / 2) + .attr("y", 30) + .attr("text-anchor", "middle") + .style("font-family", typography.title.font_family) + .style("font-size", typography.title.font_size) + .style("font-weight", typography.title.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(jsonData.title); + } + + // 添加图表描述（如果存在） + if (jsonData.description) { + svg.append("text") + .attr("x", width / 2) + .attr("y", 50) + .attr("text-anchor", "middle") + .style("font-family", typography.description.font_family) + .style("font-size", typography.description.font_size) + .style("font-weight", typography.description.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(jsonData.description); + } + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 绘制条形和标签 ---------- + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + // 为每个维度绘制条形和标签 + sortedDimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const barWidth = xScale(+dataPoint[valueField]); + + // 计算此条形的颜色 - 基于其值 + const barColor = colorScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yScale(dimension)) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", barColor) // 使用单一颜色 + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 修复: 正确设置图标大小 + const adjustedFlagWidth = Math.min(barHeight * 0.8, flagWidth); // 限制图标宽度 + const adjustedFlagHeight = Math.min(barHeight * 0.8, flagHeight); // 限制图标高度 + + // 计算每个标签的位置 + // 图标位置：紧贴条形左边 + const iconX = -adjustedFlagWidth - flagPadding; + + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + // 标签位置：在图标左侧，右对齐（相对于最长标签） + const labelX = iconX - flagPadding; + + // 序号位置：在标签最左边，考虑最长的标签 + const rankingX = labelX - maxLabelWidth - flagPadding * 2; + + // 2. 添加国家/地区标签和图标 + if (images.field && images.field[dimension]) { + // 计算裁剪圆的半径 (80% of adjustedFlagHeight/2) + const clipRadius = (adjustedFlagHeight/2) * 0.8; + + // 为每个国家图标创建唯一的clipPath ID + const clipId = `clip-${dimension.replace(/\s+/g, '-').toLowerCase()}-${index}`; + + // 添加剪切路径定义 + const defs = g.append("defs"); + + defs.append("clipPath") + .attr("id", clipId) + .append("circle") + .attr("cx", adjustedFlagWidth/2) + .attr("cy", adjustedFlagHeight/2) + .attr("r", clipRadius-2); + + // 创建一个组来包含图像和边框 + const iconGroup = g.append("g") + .attr("transform", `translate(${iconX}, ${yScale(dimension) + (barHeight - adjustedFlagHeight) / 2})`); + + // 添加黑色边框圆 - 放在图像下面但会显示在图像周围 + iconGroup.append("circle") + .attr("cx", adjustedFlagWidth/2) + .attr("cy", adjustedFlagHeight/2) + .attr("r", clipRadius) + .attr("fill", "none") + .attr("stroke", "#000000") + .attr("stroke-width", 0.2); + + // 添加裁剪后的国家/地区图标 + iconGroup.append("image") + .attr("x", 0) + .attr("y", 0) + .attr("width", adjustedFlagWidth) + .attr("height", adjustedFlagHeight) + .attr("xlink:href", images.field[dimension]) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("clip-path", `url(#${clipId})`); + } + // 添加维度标签 + g.append("text") + .attr("x", labelX) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedDimension); + + // 添加序号 + g.append("text") + .attr("x", rankingX) + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(`${index + 1}.`); + + // 格式化数值 + const formattedValue = `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}`; + + const valueLabelFontSize = `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const valueTextWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断是否能在条形内部放置文本（需要多留一些边距） + const textFitsInside = barWidth > valueTextWidth + 20; + + // 添加数值标签（在条形内部或外部） + g.append("text") + .attr("x", textFitsInside ? barWidth - 5 : barWidth + 5) // 如果放在内部，距离条形右侧5px，否则放在外部 + .attr("y", yScale(dimension) + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", textFitsInside ? "end" : "start") // 在内部时右对齐，在外部时左对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", textFitsInside ? "#ffffff" : colorResolver.text({ fallback: "#333333" }).value) // 在内部时使用白色，在外部时使用文本颜色 + .text(formattedValue); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_8.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_8.js new file mode 100644 index 0000000000000000000000000000000000000000..4cc8ed5e2b9b601b00a37e169d1cda98e56b0778 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_8.js @@ -0,0 +1,677 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_8", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], ["-inf", "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, dataJSON) { + const jsonData = dataJSON || {}; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const dataBlock = jsonData.data || {}; + const sourceRows = dataBlock.data || []; + const columns = dataBlock.columns || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const sourceColors = jsonData.colors || {}; + + d3.select(containerSelector).html(""); + + const categoryColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const valueColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const categoryField = categoryColumn.name; + const valueField = valueColumn.name; + const valueUnit = valueColumn.unit === "none" ? "" : (valueColumn.unit || ""); + + const baseWidth = Number(variables.width) || 620; + const baseHeight = Number(variables.height) || 560; + const width = Math.max(430, baseWidth); + const fontFamily = typography.label?.font_family || typography.title?.font_family || "Arial, sans-serif"; + const annotationFamily = typography.annotation?.font_family || fontFamily; + const textColor = sourceColors.text_color || "#1f2937"; + const mutedText = "#607184"; + const headerColor = "#071f46"; + const headerTextColor = "#ffffff"; + const referenceGreen = "#5b8f19"; + const referenceGreenLight = "#99c85e"; + const referenceGreenDark = "#315f12"; + const negativeColor = "#b94452"; + const panelFill = "#fdfefe"; + const plotFill = "#f6fbfd"; + const rowAltFill = "#edf6f2"; + const trackColor = "#e6f0ea"; + const gridColor = "rgba(35, 70, 95, 0.13)"; + const labelSize = Math.max(8.8, Math.min(10.2, parseFloat(typography.label?.font_size) || 10)); + const valueSize = Math.max(8.2, Math.min(9.6, parseFloat(typography.annotation?.font_size) || 9.4)); + const labelWeight = typography.label?.font_weight || "700"; + const valueWeight = typography.annotation?.font_weight || "650"; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("class", "horizontal-bar-chart-8"); + + const safeId = chartUtils.random.value(jsonData, "horizontal_bar_chart_8").toString(36).slice(2, 10); + const positiveGradientId = `horizontal-bar-8-positive-${safeId}`; + const negativeGradientId = `horizontal-bar-8-negative-${safeId}`; + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", positiveGradientId) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%") + .selectAll("stop") + .data([ + { offset: "0%", color: referenceGreenDark }, + { offset: "54%", color: referenceGreen }, + { offset: "100%", color: referenceGreenLight } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + defs.append("linearGradient") + .attr("id", negativeGradientId) + .attr("x1", "100%") + .attr("x2", "0%") + .attr("y1", "0%") + .attr("y2", "0%") + .selectAll("stop") + .data([ + { offset: "0%", color: negativeColor }, + { offset: "100%", color: "#f97373" } + ]) + .enter() + .append("stop") + .attr("offset", d => d.offset) + .attr("stop-color", d => d.color); + + function message(text) { + svg.attr("height", baseHeight).attr("viewBox", `0 0 ${width} ${baseHeight}`); + svg.append("text") + .attr("x", width / 2) + .attr("y", baseHeight / 2) + .attr("text-anchor", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", "16px") + .text(text); + return svg.node(); + } + + if (!categoryField || !valueField) return message("Missing horizontal bar fields"); + + function readableLabel(value) { + return String(value ?? "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function parseTemporalRank(value) { + const text = String(value ?? "").trim(); + const lower = text.toLowerCase(); + const months = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, + sep: 9, sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + const seasons = { winter: 1, spring: 2, summer: 3, fall: 4, autumn: 4 }; + if (months[lower] != null) return months[lower]; + let match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^Q([1-4])\s+(-?\d{4})$/i) || text.match(/^(-?\d{4})\s+Q([1-4])$/i); + if (match && text.toUpperCase().startsWith("Q")) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + match = text.match(/^(winter|spring|summer|fall|autumn)\s+(-?\d{4})$/i); + if (match) return Number(match[2]) * 10 + seasons[match[1].toLowerCase()]; + match = text.match(/^(-?\d{4})\s+(winter|spring|summer|fall|autumn)$/i); + if (match) return Number(match[1]) * 10 + seasons[match[2].toLowerCase()]; + return NaN; + } + + function parseOrdinalRank(value) { + const text = String(value ?? "").trim().toLowerCase(); + const named = { + primary: 1, elementary: 1, secondary: 2, college: 3, university: 3, + low: 1, lower: 1, medium: 2, moderate: 2, high: 3, higher: 3, + children: 1, adolescents: 2, teens: 2, adults: 3, seniors: 4 + }; + if (named[text] != null) return named[text]; + let match = text.match(/(?:less than|under)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) - 0.5; + match = text.match(/(?:more than|over)\s*[$]?\s*([\d,]+)/); + if (match) return Number(match[1].replace(/,/g, "")) + 0.5; + match = text.match(/^[$]?\s*([\d,]+(?:\.\d+)?)\s*(?:-|to)/); + if (match) return Number(match[1].replace(/,/g, "")); + match = text.match(/^(-?\d+(?:\.\d+)?)/); + if (match) return Number(match[1]); + return NaN; + } + + function compactNumber(value) { + const numeric = Number(value); + const abs = Math.abs(numeric); + if (abs >= 1000000000) return `${d3.format(".3~g")(numeric / 1000000000)}B`; + if (abs >= 1000000) return `${d3.format(".3~g")(numeric / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".3~g")(numeric / 1000)}K`; + return d3.format(",.4~g")(numeric); + } + + function formatLocalValue(value, unit = "") { + const numeric = Number(value); + const formatted = compactNumber(numeric); + if (!unit) return formatted; + if (unit === "%") return `${formatted}%`; + if (unit.startsWith("$")) { + const sign = numeric < 0 ? "-" : ""; + return `${sign}$${compactNumber(Math.abs(numeric))}${unit.slice(1)}`; + } + if (unit.length <= 3 && /^[^A-Za-z0-9]+$/.test(unit)) return `${unit}${formatted}`; + return `${formatted} ${unit}`; + } + + function truncateText(text, maxChars) { + if (text.length <= maxChars) return text; + return `${text.slice(0, Math.max(1, maxChars - 3)).trim()}...`; + } + + const grouped = new Map(); + sourceRows.forEach((row, index) => { + const category = readableLabel(row[categoryField]); + const value = Number(row[valueField]); + if (!category || !Number.isFinite(value)) return; + if (!grouped.has(category)) { + grouped.set(category, { + category, + rawCategory: row[categoryField], + firstIndex: index, + value: 0 + }); + } + grouped.get(category).value += value; + }); + + const rows = Array.from(grouped.values()).map(row => ({ + ...row, + temporalRank: parseTemporalRank(row.rawCategory), + ordinalRank: parseOrdinalRank(row.rawCategory) + })); + if (!rows.length) return message("No valid data for horizontal bars"); + + const allTemporal = categoryColumn.data_type === "temporal" || rows.every(d => Number.isFinite(d.temporalRank)); + const allOrdinal = !allTemporal && rows.every(d => Number.isFinite(d.ordinalRank)); + const sortMode = allTemporal ? "chronological" : (allOrdinal ? "ordered category" : "largest value"); + rows.sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + if (allOrdinal) return d3.ascending(a.ordinalRank, b.ordinalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.value, b.value) || d3.ascending(a.category, b.category); + }); + + function fittedFontSize(text, maxWidth, baseSize, minSize = 7.2) { + const estimated = String(text ?? "").length * baseSize * 0.55; + if (estimated <= maxWidth) return baseSize; + return Math.max(minSize, Math.min(baseSize, maxWidth / Math.max(1, String(text ?? "").length * 0.55))); + } + + const rowHeight = rows.length > 18 ? 24 : (rows.length > 12 ? 28 : 35); + const cardX = 8; + const cardY = 8; + const cardWidth = width - cardX * 2; + const cardPad = 18; + const metaY = cardY + 15; + const headerY = cardY + 61; + const headerHeight = 31; + const top = headerY + headerHeight + 12; + const footerHeight = 86; + const footerGap = 34; + const markerColumnWidth = 32; + const valueColumnWidth = Math.min(Math.max(78, width * 0.17), 118); + const labelColumnWidth = Math.min(Math.max(132, width * 0.31), 212); + const tableX = cardX + cardPad; + const tableWidth = cardWidth - cardPad * 2; + const left = tableX + markerColumnWidth + labelColumnWidth; + const valueColumnX = tableX + tableWidth - valueColumnWidth; + const innerWidth = Math.max(160, valueColumnX - left - 16); + const innerHeight = Math.max(145, rows.length * rowHeight); + const footerY = top + innerHeight + footerGap; + const height = Math.max(baseHeight, footerY + footerHeight + 18); + const cardHeight = height - cardY * 2; + svg.attr("height", height).attr("viewBox", `0 0 ${width} ${height}`); + + const minValue = d3.min(rows, d => d.value) || 0; + const maxValue = d3.max(rows, d => d.value) || 0; + const span = Math.max(1, maxValue - minValue); + const xDomain = [ + Math.min(0, minValue - span * 0.08), + Math.max(0, maxValue + span * 0.12) + ]; + const xScale = d3.scaleLinear() + .domain(xDomain) + .nice(5) + .range([0, innerWidth]); + const yScale = d3.scaleBand() + .domain(rows.map(d => d.category)) + .range([0, innerHeight]) + .padding(rows.length > 14 ? 0.31 : 0.25); + const zeroX = xScale(0); + const barHeight = Math.max(5.5, yScale.bandwidth()); + const categoryMaxWidth = Math.max(48, labelColumnWidth - 14); + const axisTitle = readableLabel(valueColumn.label || valueField || valueColumn.description); + const categoryTitle = readableLabel(categoryColumn.label || categoryField); + const valueHeader = valueUnit ? `Value (${valueUnit})` : "Value"; + + svg.append("rect") + .attr("class", "chart-style-panel") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardWidth) + .attr("height", cardHeight) + .attr("rx", 10) + .attr("fill", panelFill) + .attr("stroke", "rgba(44, 82, 112, 0.15)"); + + svg.append("rect") + .attr("class", "reference-icon-slot chart-icon-slot") + .attr("data-slot", "icon") + .attr("x", tableX) + .attr("y", metaY - 2) + .attr("width", 34) + .attr("height", 34) + .attr("rx", 8) + .attr("fill", "#eef6e7") + .attr("stroke", "rgba(49, 95, 18, 0.22)"); + + svg.append("circle") + .attr("class", "reference-icon-slot-glyph") + .attr("cx", tableX + 17) + .attr("cy", metaY + 15) + .attr("r", 8) + .attr("fill", referenceGreen) + .attr("fill-opacity", 0.88); + + svg.append("text") + .attr("class", "scale-note") + .attr("x", tableX + 47) + .attr("y", metaY + 10) + .attr("fill", headerColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.4, valueSize - 0.8)}px`) + .style("font-weight", "750") + .text(truncateText(`${axisTitle}`, Math.max(28, Math.floor((cardWidth - 190) / 5.2)))); + + svg.append("text") + .attr("class", "category-note") + .attr("x", tableX + 47) + .attr("y", metaY + 27) + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.1, valueSize - 1.2)}px`) + .text(`${categoryTitle} order: ${sortMode}`); + + const decorSlotX = cardX + cardWidth - 93; + svg.append("rect") + .attr("class", "reference-decorative-image-slot decorative-image-slot") + .attr("data-slot", "decorative-image") + .attr("x", decorSlotX) + .attr("y", metaY - 3) + .attr("width", 70) + .attr("height", 41) + .attr("rx", 9) + .attr("fill", "#f4f8fb") + .attr("stroke", "rgba(49, 95, 18, 0.18)"); + + svg.append("path") + .attr("class", "reference-decorative-image-slot-mark") + .attr("d", `M${decorSlotX + 9},${metaY + 27} C${decorSlotX + 23},${metaY + 8} ${decorSlotX + 39},${metaY + 33} ${decorSlotX + 61},${metaY + 13}`) + .attr("fill", "none") + .attr("stroke", referenceGreenLight) + .attr("stroke-width", 4) + .attr("stroke-linecap", "round"); + + svg.append("rect") + .attr("class", "chart-style-header-rule table-header") + .attr("x", tableX) + .attr("y", headerY) + .attr("width", tableWidth) + .attr("height", headerHeight) + .attr("rx", 4) + .attr("fill", headerColor); + + svg.append("text") + .attr("class", "table-header-label category-header-label") + .attr("x", tableX + markerColumnWidth + 2) + .attr("y", headerY + headerHeight / 2 + 0.5) + .attr("dominant-baseline", "middle") + .attr("fill", headerTextColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.7, valueSize - 0.4)}px`) + .style("font-weight", "800") + .text(truncateText(categoryTitle, 22)); + + svg.append("text") + .attr("class", "table-header-label axis-title") + .attr("x", left + innerWidth / 2) + .attr("y", headerY + headerHeight / 2 + 0.5) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .attr("fill", headerTextColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.7, valueSize - 0.4)}px`) + .style("font-weight", "800") + .text(truncateText(axisTitle, Math.max(20, Math.floor(innerWidth / 5.2)))); + + svg.append("text") + .attr("class", "table-header-label value-header-label") + .attr("x", valueColumnX + valueColumnWidth - 8) + .attr("y", headerY + headerHeight / 2 + 0.5) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", headerTextColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.7, valueSize - 0.4)}px`) + .style("font-weight", "800") + .text(truncateText(valueHeader, 18)); + + svg.append("rect") + .attr("class", "plot-background") + .attr("x", tableX) + .attr("y", top - 7) + .attr("width", tableWidth) + .attr("height", innerHeight + 14) + .attr("rx", 5) + .attr("fill", plotFill) + .attr("stroke", "rgba(91, 123, 148, 0.10)"); + + svg.append("line") + .attr("class", "table-column-rule label-plot-rule") + .attr("x1", left - 12) + .attr("x2", left - 12) + .attr("y1", headerY) + .attr("y2", top + innerHeight + 7) + .attr("stroke", "rgba(7, 31, 70, 0.15)") + .attr("stroke-width", 1); + + svg.append("line") + .attr("class", "table-column-rule value-column-rule") + .attr("x1", valueColumnX - 8) + .attr("x2", valueColumnX - 8) + .attr("y1", headerY) + .attr("y2", top + innerHeight + 7) + .attr("stroke", "rgba(7, 31, 70, 0.15)") + .attr("stroke-width", 1); + + const rowLayer = svg.append("g") + .attr("class", "bar-row-backgrounds"); + + const plot = svg.append("g") + .attr("class", "horizontal-bar-plot") + .attr("transform", `translate(${left}, ${top})`); + + let xTicks = xScale.ticks(5); + if (!xTicks.some(tick => Math.abs(tick) < 1e-9)) xTicks.push(0); + xTicks = Array.from(new Set(xTicks.map(tick => Number(tick.toPrecision(12))))).sort((a, b) => a - b); + + xTicks.forEach(tick => { + const x = xScale(tick); + plot.append("line") + .attr("class", "gridline x-axis-gridline") + .attr("x1", x) + .attr("x2", x) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", Math.abs(tick) < 1e-9 ? "rgba(7, 31, 70, 0.42)" : gridColor) + .attr("stroke-width", Math.abs(tick) < 1e-9 ? 1.15 : 0.85); + plot.append("text") + .attr("class", "x-axis-tick") + .attr("x", x) + .attr("y", innerHeight + 20) + .attr("text-anchor", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(6.8, valueSize - 1.3)}px`) + .style("font-weight", "650") + .text(formatLocalValue(tick, valueUnit)); + }); + + plot.append("line") + .attr("class", "axis-line zero-line") + .attr("x1", zeroX) + .attr("x2", zeroX) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", "#475569") + .attr("stroke-width", 1.45); + + rows.forEach((row, index) => { + const y = yScale(row.category); + const centerY = y + yScale.bandwidth() / 2; + const value = row.value; + const x0 = xScale(Math.min(0, value)); + const x1 = xScale(Math.max(0, value)); + const barX = Math.min(x0, x1); + const widthValue = Math.max(1, Math.abs(x1 - x0)); + const fill = value < 0 ? `url(#${negativeGradientId})` : `url(#${positiveGradientId})`; + const markerFill = d3.interpolateRgb(referenceGreenDark, referenceGreenLight)(rows.length <= 1 ? 0 : index / (rows.length - 1)); + const rowBackgroundY = top + y - Math.max(3, (rowHeight - yScale.bandwidth()) / 2); + const rowBackgroundHeight = Math.min(rowHeight - 2, yScale.bandwidth() + 7); + const absoluteCenterY = top + centerY; + const categoryFontSize = fittedFontSize(row.category, categoryMaxWidth, labelSize, 7.0); + + rowLayer.append("rect") + .attr("class", "bar-row-background") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x", tableX) + .attr("y", rowBackgroundY) + .attr("width", tableWidth) + .attr("height", rowBackgroundHeight) + .attr("rx", 4) + .attr("fill", index % 2 === 0 ? "#ffffff" : rowAltFill); + + plot.append("rect") + .attr("class", "bar-track") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x", 0) + .attr("y", centerY - barHeight * 0.34) + .attr("width", innerWidth) + .attr("height", Math.max(4.8, barHeight * 0.68)) + .attr("rx", Math.min(8, barHeight / 2)) + .attr("ry", Math.min(8, barHeight / 2)) + .attr("fill", trackColor); + + plot.append("rect") + .attr("class", "horizontal-bar data-point mark") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x", barX) + .attr("y", centerY - barHeight * 0.34) + .attr("width", widthValue) + .attr("height", Math.max(4.8, barHeight * 0.68)) + .attr("rx", Math.min(8, barHeight / 2)) + .attr("ry", Math.min(8, barHeight / 2)) + .attr("fill", fill) + .attr("fill-opacity", index === 0 && !allTemporal ? 0.98 : 0.94); + + const valueText = formatLocalValue(value, valueUnit); + const barEndX = left + (value >= 0 ? x1 : x0); + svg.append("line") + .attr("class", "value-leader") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x1", Math.max(left, Math.min(valueColumnX - 16, barEndX + (value >= 0 ? 4 : -4)))) + .attr("x2", valueColumnX - 13) + .attr("y1", absoluteCenterY) + .attr("y2", absoluteCenterY) + .attr("stroke", "rgba(49, 95, 18, 0.18)") + .attr("stroke-dasharray", "2 4") + .attr("stroke-width", 1); + + svg.append("text") + .attr("class", "value-label") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x", valueColumnX + valueColumnWidth - 8) + .attr("y", absoluteCenterY) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", headerColor) + .style("font-family", annotationFamily) + .style("font-size", `${fittedFontSize(valueText, valueColumnWidth - 14, valueSize, 6.9)}px`) + .style("font-weight", valueWeight) + .text(valueText); + + svg.append("circle") + .attr("class", "category-index-dot") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("cx", tableX + 15) + .attr("cy", absoluteCenterY) + .attr("r", Math.max(4.5, Math.min(6.0, barHeight * 0.30))) + .attr("fill", markerFill) + .attr("stroke", "rgba(255, 255, 255, 0.86)") + .attr("stroke-width", 1.2); + + svg.append("text") + .attr("class", "category-label y-axis-tick") + .attr("data-source-index", row.firstIndex) + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("x", tableX + markerColumnWidth) + .attr("y", absoluteCenterY) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", `${categoryFontSize}px`) + .style("font-weight", labelWeight) + .text(row.category); + }); + + const footer = svg.append("g") + .attr("class", "reference-footer-card") + .attr("transform", `translate(${tableX}, ${footerY})`); + + footer.append("rect") + .attr("class", "footer-card") + .attr("x", 0) + .attr("y", 0) + .attr("width", tableWidth) + .attr("height", footerHeight) + .attr("rx", 8) + .attr("fill", "#f7fbf1") + .attr("stroke", "rgba(49, 95, 18, 0.16)"); + + const footerItems = [ + { label: "Scale", text: `${formatLocalValue(xScale.domain()[0], valueUnit)} to ${formatLocalValue(xScale.domain()[1], valueUnit)}` }, + { label: "Order", text: sortMode }, + { label: "Source", text: truncateText(categoryTitle, 28) } + ]; + const footerItemWidth = tableWidth / footerItems.length; + footerItems.forEach((item, index) => { + const itemX = index * footerItemWidth; + if (index > 0) { + footer.append("line") + .attr("class", "footer-divider") + .attr("x1", itemX) + .attr("x2", itemX) + .attr("y1", 14) + .attr("y2", footerHeight - 14) + .attr("stroke", "rgba(49, 95, 18, 0.16)") + .attr("stroke-width", 1); + } + footer.append("rect") + .attr("class", "footer-icon-slot") + .attr("data-slot", `footer-icon-${index + 1}`) + .attr("x", itemX + 15) + .attr("y", 18) + .attr("width", 24) + .attr("height", 24) + .attr("rx", 6) + .attr("fill", "#ffffff") + .attr("stroke", "rgba(49, 95, 18, 0.22)"); + footer.append("circle") + .attr("class", "footer-icon-slot-dot") + .attr("cx", itemX + 27) + .attr("cy", 30) + .attr("r", 5) + .attr("fill", index === 0 ? referenceGreen : (index === 1 ? referenceGreenLight : headerColor)) + .attr("fill-opacity", 0.84); + footer.append("text") + .attr("class", "footer-label") + .attr("x", itemX + 48) + .attr("y", 29) + .attr("dominant-baseline", "middle") + .attr("fill", headerColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.6, valueSize - 0.7)}px`) + .style("font-weight", "800") + .text(item.label); + footer.append("text") + .attr("class", "footer-value") + .attr("x", itemX + 48) + .attr("y", 52) + .attr("dominant-baseline", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.1, valueSize - 1.15)}px`) + .style("font-weight", "600") + .text(truncateText(item.text, Math.max(16, Math.floor((footerItemWidth - 58) / 4.6)))); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_9.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_9.js new file mode 100644 index 0000000000000000000000000000000000000000..0875d8233741d1e4f4b470e70496373d61fd4c18 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_bar_chart_9.js @@ -0,0 +1,406 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Bar Chart", + "chart_name": "horizontal_bar_chart_9", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 多彩水平条形图实现 - 带百分比延伸背景 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "14px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#1E88E5" }, // 默认主色 + field: {} // 各维度颜色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 设置延伸条形的颜色（浅蓝色） + const extensionColor = "#e6f0fa"; // 浅蓝色背景 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + // 使用调整后的高度 + // const height = variables.height || 600; + + // 设置边距 - 后面会根据标签宽度调整左侧边距 + const margin = { + top: 90, // 顶部边距 + right: 60, // 右侧边距，留足空间放置数值 + bottom: 60, // 底部边距 + left: 120 // 左侧边距，初始值，将根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为空 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + + // 如果x维度数量超过15，每增加一个x，整个图像的高度增加3% + const baseHeight = variables.height || 600; + const adjustedHeight = dimensions.length > 15 + ? baseHeight * (1 + (dimensions.length - 15) * 0.03) + : baseHeight; + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 添加数值格式化函数 + + // ---------- 5. 测量标签宽度和调整布局 ---------- + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + // Original code section for measuring label width and adjusting margin + // Replace with this modified version: + // 函数：测量文本宽度 + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(tempSvg, text, { fontFamily: fontFamily, fontSize: parseFloat(fontSize) || fontSize, fontWeight: fontWeight }).width; + } + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 测量每个维度标签的宽度 + const textWidth = measureTextWidth( + dimension, + typography.label.font_family, + typography.label.font_size, + typography.label.font_weight + ); + + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 限制最大标签宽度为200px + maxLabelWidth = Math.min(maxLabelWidth, 200); + + // 调整左侧边距，确保有足够的空间显示标签 + margin.left = Math.max(margin.left, maxLabelWidth + 30); + + // 添加文本换行函数 + function wrapText(text, maxWidth, fontFamily, fontSize, fontWeight) { + // 如果文本不需要换行，直接返回 + const textWidth = measureTextWidth(text, fontFamily, fontSize, fontWeight); + if (textWidth <= maxWidth) { + return [text]; + } + + // 分割文本为词语数组 + const words = text.split(/\s+/); + const lines = []; + let currentLine = words[0]; + + for (let i = 1; i < words.length; i++) { + const word = words[i]; + const width = measureTextWidth(currentLine + " " + word, fontFamily, fontSize, fontWeight); + + if (width <= maxWidth) { + currentLine += " " + word; + } else { + lines.push(currentLine); + currentLine = word; + } + } + + // 添加最后一行 + lines.push(currentLine); + + // 如果没有空格分隔词（如中文），则按字符分割 + if (lines.length === 1 && measureTextWidth(lines[0], fontFamily, fontSize, fontWeight) > maxWidth) { + const chars = text.split(''); + lines.length = 0; + currentLine = chars[0]; + + for (let i = 1; i < chars.length; i++) { + const char = chars[i]; + const width = measureTextWidth(currentLine + char, fontFamily, fontSize, fontWeight); + + if (width <= maxWidth) { + currentLine += char; + } else { + lines.push(currentLine); + currentLine = char; + } + } + + // 添加最后一行 + lines.push(currentLine); + } + + return lines; + } + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = adjustedHeight - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", adjustedHeight) + .attr("viewBox", `0 0 ${width} ${adjustedHeight}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值）- 0-100% + const xScale = d3.scaleLinear() + .domain([0, 100]) + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 绘制延伸背景和条形 ---------- + + // 为每个维度绘制条形 + dimensions.forEach((dimension, index) => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const barHeight = yScale.bandwidth(); + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 获取条形颜色 - 从colors.field中获取，如果不存在则使用默认主色 + let barColor = colorResolver.other("primary").value; + barColor = colorResolver.field(dimension, 0, { fallback: barColor }).value; + + // 创建条形组 + const barGroup = g.append("g") + .attr("transform", `translate(0, ${yScale(dimension)})`); + + // 绘制100%延伸背景 + barGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", innerWidth) + .attr("height", barHeight) + .attr("class","background") + .attr("fill", extensionColor) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0); + + // 绘制实际数值条形 + barGroup.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + d3.interpolateRgb(barColor, colorResolver.variant(barColor, { mode: "brighter", amount: 0.5 }))(0.5) : + barColor) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? colorResolver.variant(barColor, { mode: "darker", amount: 0.2 }) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${barHeight * 0.4}px`; + + // 格式化数值用于显示（根据条形是否有足够空间决定显示位置） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + const valueTextWidth = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: dynamicFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断数值标签是否能放入条形内 + const labelFitsInside = valueTextWidth + 10 < barWidth; + + // 添加数值标签（使用动态字体大小） + if (labelFitsInside) { + // 标签放在条形内部左侧 + barGroup.append("text") + .attr("x", barWidth - 5) // 条形内左侧5px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "end") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色 + .text(formattedValue); + } else { + // 标签放在条形外部左侧 + barGroup.append("text") + .attr("x", barWidth + 5) // 条形外左侧5px + .attr("y", barHeight / 2) + .attr("dy", "0.35em") // 垂直居中 + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用文本颜色 + .text(formattedValue); + } + + + + const wrappedText = wrapText( + dimension, + maxLabelWidth, + typography.label.font_family, + typography.label.font_size, + typography.label.font_weight + ); + + // 计算行高 + const lineHeight = parseInt(typography.label.font_size) * 1.2; + + // 计算文本总高度 + const textHeight = wrappedText.length * lineHeight; + + // 创建文本组 + const labelGroup = barGroup.append("g") + .attr("transform", `translate(${-maxLabelWidth - 10}, ${barHeight / 2 - textHeight / 2 + lineHeight / 2})`); + + // 添加每一行文本 + wrappedText.forEach((line, i) => { + labelGroup.append("text") + .attr("x", 0) + .attr("y", i * lineHeight) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(line); + }); + } + }); + + + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..2d4a75e304e001f057ac38027c31769a763d17b6 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01.js @@ -0,0 +1,592 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], ["-inf", "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const rawData = (jsonData.data && jsonData.data.data) ? jsonData.data.data : []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const width = variables.width || 800; + const height = variables.height || 600; + const dimensionChannel = chartUtils.schema.channel(jsonData, "x", { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.channel(jsonData, "y", { fallbackKey: "value" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const valueUnit = valueChannel.unit || ""; + + const rows = rawData + .map((d, index) => ({ + raw: d, + index, + label: String(d[dimensionField]), + value: +d[valueField] + })) + .filter(d => Number.isFinite(d.value)) + .sort((a, b) => a.value - b.value); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart", "horizontal_diverging_bar_chart_01") + .attr("data-reference-style", "table-diverging-bars"); + + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", "hdbar01-panel-shadow") + .attr("x", "-12%") + .attr("y", "-12%") + .attr("width", "124%") + .attr("height", "128%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 7) + .attr("flood-color", "#8fb5ca") + .attr("flood-opacity", 0.24); + + const headerGradient = defs.append("linearGradient") + .attr("id", "hdbar01-header-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + headerGradient.append("stop").attr("offset", "0%").attr("stop-color", "#073f6e"); + headerGradient.append("stop").attr("offset", "100%").attr("stop-color", "#3454d1"); + + const cueLowColor = "#18a75b"; + const cueMidColor = "#f3c736"; + const cueHighColor = "#e6372f"; + const cueGradient = defs.append("linearGradient") + .attr("id", "hdbar01-cue-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%"); + cueGradient.append("stop").attr("offset", "0%").attr("stop-color", cueLowColor); + cueGradient.append("stop").attr("offset", "48%").attr("stop-color", cueMidColor); + cueGradient.append("stop").attr("offset", "100%").attr("stop-color", cueHighColor); + + if (!rows.length) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "18px") + .style("fill", colorResolver.text({ fallback: "#183153" }).value) + .text("No data"); + return svg.node(); + } + + const maxAbsValue = d3.max(rows, d => Math.abs(d.value)) || 1; + const minValue = d3.min(rows, d => d.value) || 0; + const maxValue = d3.max(rows, d => d.value) || 0; + + const chartMargin = { + top: Math.max(18, height * 0.035), + right: Math.max(20, width * 0.035), + bottom: Math.max(16, height * 0.03), + left: Math.max(72, width * 0.13) + }; + const cueX = Math.max(36, chartMargin.left * 0.56); + const tableX = chartMargin.left + Math.max(22, width * 0.03); + const tableY = chartMargin.top + Math.max(8, height * 0.015); + const tableW = width - tableX - chartMargin.right; + const tableH = height - tableY - chartMargin.bottom; + const headerH = Math.max(44, Math.min(64, tableH * 0.13)); + const bodyY = tableY + headerH; + const bodyH = tableH - headerH; + const rowH = bodyH / rows.length; + const iconR = Math.max(9, Math.min(18, rowH * 0.27)); + const panelRadius = Math.max(14, Math.min(22, width * 0.028)); + const methodW = tableW * 0.42; + const dividerX = tableX + methodW; + const iconX = tableX + Math.max(24, tableW * 0.075); + const labelX = iconX + iconR + Math.max(15, tableW * 0.035); + const labelW = dividerX - labelX - 14; + const barStart = dividerX + Math.max(18, tableW * 0.035); + const valueAreaRight = tableX + tableW - Math.max(20, tableW * 0.03); + const maxValueTextWidth = Math.max(56, tableW * 0.10); + const barMaxW = Math.max(36, valueAreaRight - maxValueTextWidth - barStart - 10); + const negativeMax = Math.abs(Math.min(0, minValue)); + const positiveMax = Math.max(0, maxValue); + const signedTotal = Math.max(1e-6, negativeMax + positiveMax); + const negativeSpan = Math.max(negativeMax > 0 ? 18 : 0, barMaxW * (negativeMax / signedTotal)); + const positiveSpan = Math.max(positiveMax > 0 ? 18 : 0, barMaxW - negativeSpan); + const barZeroX = barStart + negativeSpan; + const trackH = Math.max(7, Math.min(20, rowH * 0.34)); + const labelFont = Math.max(11, Math.min(16, rowH * 0.27)); + const valueFont = Math.max(13, Math.min(21, rowH * 0.34)); + const unitFont = Math.max(8, Math.min(13, valueFont * 0.58)); + const textColor = colorResolver.text({ fallback: "#092144" }).value || "#092144"; + const cueEndpointR = Math.max(16, iconR * 1.25); + const contentBgInsetX = Math.max(18, width * 0.023); + const contentBgInsetY = Math.max(10, height * 0.016); + const contentBgW = width - contentBgInsetX * 2; + const contentVisualLeft = cueX - cueEndpointR; + const contentVisualRight = tableX + tableW; + const contentVisualCenter = (contentVisualLeft + contentVisualRight) / 2; + const contentBgX = Math.max(0, Math.min(width - contentBgW, contentVisualCenter - contentBgW / 2)); + const contentBgRight = contentBgX + contentBgW; + const contentBgY = contentBgInsetY; + const contentBgBottom = height - contentBgInsetY; + + svg.append("rect") + .attr("class", "hdbar01-background") + .attr("x", contentBgX) + .attr("y", contentBgY) + .attr("width", contentBgRight - contentBgX) + .attr("height", contentBgBottom - contentBgY) + .attr("fill", "#ffffff") + .attr("opacity", 0.62); + + const panelClipId = "hdbar01-panel-clip"; + defs.append("clipPath") + .attr("id", panelClipId) + .append("rect") + .attr("x", tableX) + .attr("y", tableY) + .attr("width", tableW) + .attr("height", tableH) + .attr("rx", panelRadius) + .attr("ry", panelRadius); + + svg.append("rect") + .attr("class", "hdbar01-table-panel") + .attr("data-role", "chart-table-panel") + .attr("x", tableX) + .attr("y", tableY) + .attr("width", tableW) + .attr("height", tableH) + .attr("rx", panelRadius) + .attr("fill", "#ffffff") + .attr("filter", "url(#hdbar01-panel-shadow)"); + + const table = svg.append("g") + .attr("class", "hdbar01-table") + .attr("clip-path", `url(#${panelClipId})`); + + table.append("rect") + .attr("class", "hdbar01-header") + .attr("x", tableX) + .attr("y", tableY) + .attr("width", tableW) + .attr("height", headerH) + .attr("fill", "url(#hdbar01-header-gradient)"); + + table.append("line") + .attr("class", "hdbar01-column-divider") + .attr("x1", dividerX) + .attr("y1", tableY) + .attr("x2", dividerX) + .attr("y2", tableY + tableH) + .attr("stroke", "#d7e9f2") + .attr("stroke-width", 1.4); + + const headerFont = Math.max(10, Math.min(15, headerH * 0.28)); + table.append("text") + .attr("class", "hdbar01-column-title method-title") + .attr("x", tableX + methodW / 2) + .attr("y", tableY + headerH / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${headerFont}px`) + .style("font-weight", 800) + .style("letter-spacing", "0px") + .style("fill", "#ffffff") + .text(formatHeaderName(dimensionChannel.name || dimensionField).toUpperCase()); + + const valueHeader = `${formatHeaderName(valueChannel.name || valueField).toUpperCase()}${valueUnit ? ` (${valueUnit})` : ""}`; + const headerLines = wrapWords(valueHeader, Math.max(13, Math.floor((tableW - methodW - 24) / (headerFont * 0.58))), 2); + const headerText = table.append("text") + .attr("class", "hdbar01-column-title value-title") + .attr("x", dividerX + (tableW - methodW) / 2) + .attr("y", tableY + headerH / 2 - (headerLines.length - 1) * headerFont * 0.45) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${headerFont}px`) + .style("font-weight", 800) + .style("letter-spacing", "0px") + .style("fill", "#ffffff"); + headerLines.forEach((line, i) => { + headerText.append("tspan") + .attr("x", dividerX + (tableW - methodW) / 2) + .attr("dy", i === 0 ? "0.35em" : `${headerFont * 1.1}px`) + .text(line); + }); + + rows.forEach((d, rowIndex) => { + const y0 = bodyY + rowIndex * rowH; + const cy = y0 + rowH / 2; + const slotColor = severityColor(d.value, minValue, maxValue); + const row = table.append("g") + .attr("class", "hdbar01-row") + .attr("data-row-index", rowIndex) + .attr("data-category", d.label) + .attr("data-value", d.value); + + if (rowIndex > 0) { + row.append("line") + .attr("class", "hdbar01-row-separator") + .attr("x1", tableX) + .attr("y1", y0) + .attr("x2", tableX + tableW) + .attr("y2", y0) + .attr("stroke", "#d7e9f2") + .attr("stroke-width", 1); + } + + row.append("circle") + .attr("class", "reserved-asset-slot hdbar01-row-icon-slot") + .attr("data-asset-slot", "row-icon") + .attr("data-category", d.label) + .attr("cx", iconX) + .attr("cy", cy) + .attr("r", iconR) + .attr("fill", tint(slotColor, 0.86)) + .attr("stroke", tint(slotColor, 0.58)) + .attr("stroke-width", 1.1); + + row.append("circle") + .attr("class", "hdbar01-neutral-row-icon-mark") + .attr("cx", iconX) + .attr("cy", cy) + .attr("r", Math.max(2.6, iconR * 0.22)) + .attr("fill", slotColor) + .attr("opacity", 0.82); + + const labelLines = wrapMeasured(row, d.label, labelW, labelFont, typography.label.font_family, 700, Math.max(1, Math.min(2, Math.floor(rowH / (labelFont * 1.08))))); + const label = row.append("text") + .attr("class", "hdbar01-method-label") + .attr("x", labelX) + .attr("y", cy - (labelLines.length - 1) * labelFont * 0.52) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelFont}px`) + .style("font-weight", 700) + .style("fill", textColor); + labelLines.forEach((line, i) => { + label.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${labelFont * 1.1}px`) + .text(line); + }); + + row.append("rect") + .attr("class", "hdbar01-bar-track") + .attr("x", barStart) + .attr("y", cy - trackH / 2) + .attr("width", barMaxW) + .attr("height", trackH) + .attr("rx", trackH * 0.42) + .attr("fill", "#eaf3f7"); + + row.append("line") + .attr("class", "hdbar01-zero-axis-tick") + .attr("x1", barZeroX) + .attr("y1", cy - trackH * 0.78) + .attr("x2", barZeroX) + .attr("y2", cy + trackH * 0.78) + .attr("stroke", "#9eb7c5") + .attr("stroke-width", 1) + .attr("opacity", 0.65); + + const isNegative = d.value < 0; + const sideSpan = isNegative ? negativeSpan : positiveSpan; + const sideMax = isNegative ? negativeMax : positiveMax; + const barRatio = sideMax > 0 ? Math.min(1, Math.abs(d.value) / sideMax) : 0; + const renderedBarW = Math.max( + Math.max(4, sideSpan * 0.04), + barRatio * sideSpan + ); + const barX = isNegative ? barZeroX - renderedBarW : barZeroX; + + row.append("rect") + .attr("class", "hdbar01-emissions-bar") + .attr("data-role", "bar") + .attr("data-category", d.label) + .attr("data-value", d.value) + .attr("x", barX) + .attr("y", cy - trackH / 2) + .attr("width", renderedBarW) + .attr("height", trackH) + .attr("rx", trackH * 0.36) + .attr("fill", slotColor); + + const labelGap = Math.max(8, tableW * 0.015); + const preferredValueX = barX + renderedBarW + labelGap; + const valueX = Math.min(preferredValueX, valueAreaRight - maxValueTextWidth * 0.52); + const formatted = `${d.value >= 0 ? "+" : ""}${chartUtils.format.autoText(d.value)}`; + const valueText = row.append("text") + .attr("class", "hdbar01-value-label") + .attr("data-role", "value-label") + .attr("x", valueX) + .attr("y", cy) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueFont}px`) + .style("font-weight", 800) + .style("fill", "#071f45"); + valueText.append("tspan").text(formatted); + if (valueUnit) { + valueText.append("tspan") + .attr("dx", Math.max(3, valueFont * 0.2)) + .style("font-size", `${unitFont}px`) + .style("font-weight", 700) + .style("fill", "#183153") + .text(valueUnit); + } + }); + + const cueLabelFont = Math.max(8, Math.min(11, rowH * 0.18)); + const cueTop = bodyY + Math.max(cueEndpointR + cueLabelFont * 2.8 + 14, rowH * 0.58); + const cueBottom = bodyY + bodyH - Math.max(cueEndpointR + cueLabelFont * 2.8 + 14, rowH * 0.72); + const cue = svg.append("g") + .attr("class", "hdbar01-emissions-cue") + .attr("data-role", "low-high-emissions-cue"); + + cue.append("circle") + .attr("class", "reserved-asset-slot hdbar01-cue-endpoint-slot low") + .attr("data-asset-slot", "emissions-cue-endpoint") + .attr("data-endpoint", "low") + .attr("cx", cueX) + .attr("cy", cueTop) + .attr("r", cueEndpointR) + .attr("fill", "#f8fff9") + .attr("stroke", "#15964f") + .attr("stroke-width", 2); + + cue.append("circle") + .attr("cx", cueX) + .attr("cy", cueTop) + .attr("r", 4) + .attr("fill", "#15964f") + .attr("opacity", 0.72); + + const cueStroke = Math.max(4, width * 0.008); + const cueLineTop = cueTop + cueEndpointR + 14; + const cueLineBottom = cueBottom - cueEndpointR - 14; + const cueLineMid1 = cueLineTop + (cueLineBottom - cueLineTop) * 0.36; + const cueLineMid2 = cueLineTop + (cueLineBottom - cueLineTop) * 0.64; + [ + [cueLineTop, cueLineMid1, cueLowColor], + [cueLineMid1, cueLineMid2, cueMidColor], + [cueLineMid2, cueLineBottom, cueHighColor] + ].forEach(([y1, y2, stroke], index) => { + cue.append("line") + .attr("class", "hdbar01-cue-shaft") + .attr("data-cue-segment", index) + .attr("x1", cueX) + .attr("y1", y1) + .attr("x2", cueX) + .attr("y2", y2) + .attr("stroke", stroke) + .attr("stroke-width", cueStroke) + .attr("stroke-linecap", "round"); + }); + + cue.append("path") + .attr("class", "hdbar01-cue-arrowhead top") + .attr("d", `M ${cueX - 9},${cueLineTop + 10} L ${cueX + 9},${cueLineTop + 10} L ${cueX},${cueLineTop - 6} Z`) + .attr("fill", cueLowColor); + + cue.append("path") + .attr("class", "hdbar01-cue-arrowhead bottom") + .attr("d", `M ${cueX - 9},${cueLineBottom - 10} L ${cueX + 9},${cueLineBottom - 10} L ${cueX},${cueLineBottom + 6} Z`) + .attr("fill", cueHighColor); + + cue.append("circle") + .attr("class", "reserved-asset-slot hdbar01-cue-endpoint-slot high") + .attr("data-asset-slot", "emissions-cue-endpoint") + .attr("data-endpoint", "high") + .attr("cx", cueX) + .attr("cy", cueBottom) + .attr("r", cueEndpointR) + .attr("fill", "#fffafa") + .attr("stroke", "#cf2824") + .attr("stroke-width", 2); + + cue.append("circle") + .attr("cx", cueX) + .attr("cy", cueBottom) + .attr("r", 4) + .attr("fill", "#cf2824") + .attr("opacity", 0.72); + + const cueMetric = compactCueMetric(valueChannel.name || valueField); + addCueLabel(cue, "LOWEST", cueMetric, cueX, cueTop - cueEndpointR - cueLabelFont * 1.55, "#15814a", typography.label.font_family, cueLabelFont); + addCueLabel(cue, "HIGHEST", cueMetric, cueX, cueBottom + cueEndpointR + cueLabelFont * 1.05, "#c62421", typography.label.font_family, cueLabelFont); + + return svg.node(); + + function addCueLabel(parent, line1, line2, x, y, fill, fontFamily, fontSize) { + const text = parent.append("text") + .attr("class", "hdbar01-cue-label") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", "middle") + .style("font-family", fontFamily) + .style("font-size", `${fontSize}px`) + .style("font-weight", 800) + .style("fill", fill); + text.append("tspan").attr("x", x).text(line1); + text.append("tspan").attr("x", x).attr("dy", `${fontSize * 1.12}px`).text(line2); + } + + function wrapWords(text, maxChars, maxLines) { + const words = String(text).split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const next = current ? `${current} ${word}` : word; + if (next.length <= maxChars || !current) { + current = next; + } else { + lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const trimmed = lines.slice(0, maxLines); + trimmed[maxLines - 1] = `${trimmed[maxLines - 1].replace(/\.*$/, "")}...`; + return trimmed; + } + return lines; + } + + function formatHeaderName(value) { + return String(value) + .replace(/[_-]+/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function compactCueMetric(value) { + const cleaned = formatHeaderName(value) + .replace(/\([^)]*\)/g, " ") + .replace(/\b(intensity|rate|score|index|percent|percentage|amount|total|average|avg|value)\b/gi, " ") + .replace(/\s+/g, " ") + .trim(); + if (/emission/i.test(value)) return "EMISSIONS"; + if (/deficit/i.test(value)) return "DEFICIT"; + if (/surplus/i.test(value)) return "SURPLUS"; + if (/change/i.test(value)) return "CHANGE"; + if (/sales/i.test(value)) return "SALES"; + const words = cleaned.split(/\s+/).filter(Boolean); + return (words[0] || "VALUE").toUpperCase(); + } + + function wrapMeasured(parent, text, maxWidth, fontSize, fontFamily, fontWeight, maxLines) { + const words = String(text).split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const next = current ? `${current} ${word}` : word; + const nextWidth = chartUtils.text.measure(parent, next, { + fontFamily, + fontSize, + fontWeight + }).width; + if (nextWidth <= maxWidth || !current) { + current = next; + } else { + lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const trimmed = lines.slice(0, maxLines); + let last = trimmed[maxLines - 1]; + while (last.length > 4 && chartUtils.text.measure(parent, `${last}...`, { + fontFamily, + fontSize, + fontWeight + }).width > maxWidth) { + last = last.replace(/\s*\S+$/, ""); + } + trimmed[maxLines - 1] = `${(last || String(text).slice(0, 8)).trim()}...`; + return trimmed; + } + return lines; + } + + function severityColor(value, minValue, maxValue) { + if (value < 0) { + const negativeFloor = Math.min(0, minValue); + const t = Math.max(0, Math.min(1, (value - negativeFloor) / Math.max(1e-6, -negativeFloor))); + return interpolateColorStops(t, [ + [0.00, cueLowColor], + [1.00, cueMidColor] + ]); + } + + const positiveCeiling = Math.max(0, maxValue); + const t = Math.max(0, Math.min(1, value / Math.max(1e-6, positiveCeiling))); + return interpolateColorStops(t, [ + [0.00, cueMidColor], + [1.00, cueHighColor] + ]); + } + + function interpolateColorStops(t, stops) { + for (let i = 1; i < stops.length; i++) { + const [prevT, prevColor] = stops[i - 1]; + const [nextT, nextColor] = stops[i]; + if (t <= nextT) { + const localT = (t - prevT) / Math.max(1e-6, nextT - prevT); + return d3.interpolateRgb(prevColor, nextColor)(Math.max(0, Math.min(1, localT))); + } + } + return stops[stops.length - 1][1]; + } + + function tint(hex, amount) { + const c = d3.color(hex); + if (!c) return hex; + const r = Math.round(c.r + (255 - c.r) * amount); + const g = Math.round(c.g + (255 - c.g) * amount); + const b = Math.round(c.b + (255 - c.b) * amount); + return `rgb(${r},${g},${b})`; + } +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..0d860e16e11fc11525bc41244a3b2eeffaaeb83a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_01_hand.js @@ -0,0 +1,453 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_01_hand", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 15], ["-inf", "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const rawData = (jsonData.data && jsonData.data.data) ? jsonData.data.data : []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = variables.height || 600; + + const dimensionChannel = chartUtils.schema.channel(jsonData, "x", { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.channel(jsonData, "y", { fallbackKey: "value" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const valueUnit = valueChannel.unit || ""; + const rows = rawData + .map((d, index) => ({ + raw: d, + index, + label: String(d[dimensionField]), + value: +d[valueField] + })) + .filter(d => Number.isFinite(d.value)) + .sort((a, b) => a.value - b.value); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart", "horizontal_diverging_bar_chart_01_hand") + .attr("data-reference-style", "news-bias-diverging-panel"); + + const defs = svg.append("defs"); + + const panelClipId = "hdbar01hand-panel-clip"; + const plotClipId = "hdbar01hand-plot-clip"; + const panelX = Math.max(18, width * 0.045); + const panelY = Math.max(10, height * 0.02); + const panelW = width - panelX * 2; + const panelH = height - panelY * 2; + const tabY = panelY + Math.max(8, panelH * 0.028); + const tabH = Math.max(18, Math.min(28, panelH * 0.047)); + const chipH = Math.max(58, Math.min(76, panelH * 0.13)); + const chipY = panelY + panelH - chipH - Math.max(16, panelH * 0.03); + const plotTop = tabY + tabH + Math.max(16, panelH * 0.035); + const plotBottom = chipY - Math.max(20, panelH * 0.035); + const plotH = Math.max(120, plotBottom - plotTop); + const iconX = panelX + Math.max(22, panelW * 0.055); + const labelX = iconX + Math.max(19, panelW * 0.044); + const labelW = Math.max(78, panelW * 0.235); + const plotX0 = labelX + labelW + Math.max(18, panelW * 0.035); + const plotX1 = panelX + panelW - Math.max(44, panelW * 0.07); + const valueLabelReserve = Math.max(58, Math.min(86, panelW * 0.13)); + const scaleX0 = plotX0 + valueLabelReserve; + const scaleX1 = plotX1 - valueLabelReserve; + const zeroX = scaleX0 + (scaleX1 - scaleX0) * 0.5; + const maxAbs = Math.max(1e-6, d3.max(rows, d => Math.abs(d.value)) || 1); + const xScale = d3.scaleLinear() + .domain([-maxAbs, maxAbs]) + .range([scaleX0, scaleX1]); + const yScale = d3.scaleBand() + .domain(rows.map(d => d.label)) + .range([plotTop, plotTop + plotH]) + .padding(rows.length > 12 ? 0.18 : 0.24); + const rowH = Math.max(1, yScale.bandwidth()); + const barH = Math.max(5, Math.min(18, rowH * 0.52)); + const labelFont = Math.max(7.5, Math.min(11, rowH * 0.38)); + const valueFont = Math.max(7.5, Math.min(10.5, rowH * 0.38)); + const textColor = colorResolver.text({ fallback: "#11223f" }).value || "#11223f"; + const leftColor = "#0B5CA8"; + const rightColor = "#E3322B"; + + defs.append("clipPath") + .attr("id", panelClipId) + .append("rect") + .attr("x", panelX) + .attr("y", panelY) + .attr("width", panelW) + .attr("height", panelH) + .attr("rx", 2); + + defs.append("clipPath") + .attr("id", plotClipId) + .append("rect") + .attr("x", panelX + 4) + .attr("y", plotTop - 7) + .attr("width", panelW - 8) + .attr("height", plotH + 14); + + svg.append("rect") + .attr("class", "hdbar01hand-page") + .attr("x", 0) + .attr("y", 0) + .attr("width", width) + .attr("height", height) + .attr("fill", "#FFFFFF"); + + svg.append("rect") + .attr("class", "hdbar01hand-panel") + .attr("data-role", "chart-panel") + .attr("x", panelX) + .attr("y", panelY) + .attr("width", panelW) + .attr("height", panelH) + .attr("rx", 2) + .attr("fill", "#FFFFFF") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 0); + + if (!rows.length) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "18px") + .style("fill", textColor) + .text("No data"); + return svg.node(); + } + + const chart = svg.append("g") + .attr("class", "hdbar01hand-chart") + .attr("clip-path", `url(#${panelClipId})`); + + const tabOuterPad = Math.max(10, panelW * 0.018); + const leftTabX = panelX + tabOuterPad; + const rightTabEdge = panelX + panelW - tabOuterPad; + addTab(chart, leftTabX, tabY, zeroX - leftTabX - 2, tabH, leftColor, "<- LEFT-LEANING"); + addTab(chart, zeroX + 2, tabY, rightTabEdge - zeroX - 2, tabH, rightColor, "RIGHT-LEANING ->"); + + chart.append("text") + .attr("class", "hdbar01hand-zero-label") + .attr("x", zeroX) + .attr("y", tabY + tabH + 12) + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(7, valueFont * 0.92)}px`) + .style("font-weight", 800) + .style("fill", "#343F52") + .text("0"); + + const ticks = xScale.ticks(5).filter(t => Math.abs(t) <= maxAbs + 1e-9); + ticks.forEach(t => { + const x = xScale(t); + chart.append("line") + .attr("class", "hdbar01hand-gridline") + .attr("x1", x) + .attr("x2", x) + .attr("y1", plotTop - 6) + .attr("y2", plotTop + plotH + 4) + .attr("stroke", Math.abs(t) < 1e-9 ? "#536071" : "#E7ECF3") + .attr("stroke-width", Math.abs(t) < 1e-9 ? 1.2 : 0.8); + chart.append("text") + .attr("class", "hdbar01hand-tick-label") + .attr("x", x) + .attr("y", plotTop + plotH + 15) + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(6.5, valueFont * 0.78)}px`) + .style("fill", "#657083") + .text(formatTick(t)); + }); + + const rowLayer = chart.append("g") + .attr("class", "hdbar01hand-row-layer") + .attr("clip-path", `url(#${plotClipId})`); + + rows.forEach((d, rowIndex) => { + const cy = yScale(d.label) + rowH / 2; + const barColor = d.value < 0 ? leftColor : rightColor; + const x0 = xScale(0); + const x1 = xScale(d.value); + const barX = Math.min(x0, x1); + const barW = Math.max(1.5, Math.abs(x1 - x0)); + const row = rowLayer.append("g") + .attr("class", "hdbar01hand-row") + .attr("data-row-index", rowIndex) + .attr("data-category", d.label) + .attr("data-value", d.value); + + row.append("line") + .attr("class", "hdbar01hand-row-guide") + .attr("x1", panelX + 10) + .attr("x2", panelX + panelW - 10) + .attr("y1", cy) + .attr("y2", cy) + .attr("stroke", "#EEF2F6") + .attr("stroke-width", 0.8); + + row.append("circle") + .attr("class", "reserved-asset-slot hdbar01hand-row-source-logo-slot") + .attr("data-asset-slot", "row-source-logo") + .attr("data-category", d.label) + .attr("data-anchor", "row-centerline-left-label-column") + .attr("data-collision-rule", "stay-left-of-category-label-and-inside-panel") + .attr("data-slot-policy", "retrieval_or_image2_asset") + .attr("cx", iconX) + .attr("cy", cy) + .attr("r", Math.max(5, Math.min(9, rowH * 0.30))) + .attr("fill", tint(barColor, 0.82)) + .attr("stroke", barColor) + .attr("stroke-width", 0.9); + + row.append("text") + .attr("class", "hdbar01hand-row-logo-placeholder") + .attr("x", iconX) + .attr("y", cy) + .attr("dy", "0.32em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(5.5, rowH * 0.22)}px`) + .style("font-weight", 800) + .style("fill", barColor) + .text(abbrev(d.label)); + + const labelLines = wrapMeasured(row, d.label, labelW, labelFont, typography.label.font_family, 700, rowH < 18 ? 1 : 2); + const label = row.append("text") + .attr("class", "hdbar01hand-category-label") + .attr("x", labelX) + .attr("y", cy - (labelLines.length - 1) * labelFont * 0.52) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelFont}px`) + .style("font-weight", 700) + .style("fill", textColor); + labelLines.forEach((line, i) => { + label.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${labelFont * 1.05}px`) + .text(line); + }); + + row.append("rect") + .attr("class", "hdbar01hand-bar") + .attr("data-role", "bar") + .attr("data-category", d.label) + .attr("data-value", d.value) + .attr("x", barX) + .attr("y", cy - barH / 2) + .attr("width", barW) + .attr("height", barH) + .attr("rx", Math.min(4, barH * 0.35)) + .attr("fill", barColor); + + const formatted = `${d.value >= 0 ? "+" : ""}${chartUtils.format.autoText(d.value)}${valueUnit}`; + const labelGap = Math.max(4, panelW * 0.008); + const estimatedTextW = formatted.length * valueFont * 0.58; + let valueX; + let anchor; + if (d.value < 0) { + valueX = Math.max(plotX0 + 2, barX - labelGap); + anchor = "end"; + if (valueX - estimatedTextW < plotX0 + 2) { + valueX = plotX0 + 2; + anchor = "start"; + } + } else { + valueX = Math.min(plotX1 - 2, barX + barW + labelGap); + anchor = "start"; + if (valueX + estimatedTextW > plotX1 - 2) { + valueX = plotX1 - 2; + anchor = "end"; + } + } + row.append("text") + .attr("class", "hdbar01hand-value-label") + .attr("data-role", "value-label") + .attr("x", valueX) + .attr("y", cy) + .attr("dy", "0.35em") + .attr("text-anchor", anchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${valueFont}px`) + .style("font-weight", 800) + .style("fill", barColor) + .text(formatted); + }); + + const chipLayer = chart.append("g") + .attr("class", "hdbar01hand-classification-chips") + .attr("data-role", "bottom-classification-chips"); + const chipGap = Math.max(8, panelW * 0.018); + const chipW = (panelW - chipGap * 4) / 3; + const chips = [ + { title: "Left-Leaning", body: "negative signed scores", color: leftColor }, + { title: "Center", body: "near the zero line", color: "#58667A" }, + { title: "Right-Leaning", body: "positive signed scores", color: rightColor } + ]; + chips.forEach((chip, i) => { + const x = panelX + chipGap + i * (chipW + chipGap); + const g = chipLayer.append("g") + .attr("class", "hdbar01hand-chip") + .attr("data-chip", chip.title.toLowerCase().replace(/[^a-z]+/g, "-")); + g.append("rect") + .attr("x", x) + .attr("y", chipY) + .attr("width", chipW) + .attr("height", chipH) + .attr("rx", 8) + .attr("fill", tint(chip.color, 0.92)) + .attr("stroke", tint(chip.color, 0.52)) + .attr("stroke-width", 1); + g.append("circle") + .attr("class", "reserved-asset-slot hdbar01hand-chip-icon-slot") + .attr("data-asset-slot", "classification-chip-icon") + .attr("data-anchor", "chip-left-centerline") + .attr("data-collision-rule", "stay-inside-chip-and-left-of-chip-text") + .attr("data-slot-policy", "neutral_placeholder") + .attr("cx", x + Math.max(14, chipW * 0.13)) + .attr("cy", chipY + chipH / 2) + .attr("r", Math.max(7, Math.min(10, chipH * 0.16))) + .attr("fill", chip.color); + g.append("text") + .attr("x", x + Math.max(31, chipW * 0.26)) + .attr("y", chipY + chipH * 0.42) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.max(8.5, Math.min(11, chipW * 0.072))}px`) + .style("font-weight", 800) + .style("fill", "#182338") + .text(chip.title); + g.append("text") + .attr("x", x + Math.max(31, chipW * 0.26)) + .attr("y", chipY + chipH * 0.68) + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(6.8, Math.min(8.5, chipW * 0.058))}px`) + .style("font-weight", 600) + .style("fill", "#526071") + .text(chip.body); + }); + + return svg.node(); + + function addTab(parent, x, y, w, h, fill, label) { + parent.append("rect") + .attr("class", "hdbar01hand-direction-tab") + .attr("data-role", "direction-tab") + .attr("x", x) + .attr("y", y) + .attr("width", Math.max(1, w)) + .attr("height", h) + .attr("rx", 4) + .attr("fill", fill); + parent.append("text") + .attr("class", "hdbar01hand-direction-tab-label") + .attr("x", x + w / 2) + .attr("y", y + h / 2) + .attr("dy", "0.34em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.max(8, Math.min(11, h * 0.42))}px`) + .style("font-weight", 800) + .style("fill", "#FFFFFF") + .text(label); + } + + function wrapMeasured(parent, text, maxWidth, fontSize, fontFamily, fontWeight, maxLines) { + const words = String(text).split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const next = current ? `${current} ${word}` : word; + const nextWidth = chartUtils.text.measure(parent, next, { + fontFamily, + fontSize, + fontWeight + }).width; + if (nextWidth <= maxWidth || !current) { + current = next; + } else { + lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const trimmed = lines.slice(0, maxLines); + let last = trimmed[maxLines - 1]; + while (last.length > 3 && chartUtils.text.measure(parent, `${last}...`, { + fontFamily, + fontSize, + fontWeight + }).width > maxWidth) { + last = last.replace(/\s*\S+$/, ""); + } + trimmed[maxLines - 1] = `${(last || String(text).slice(0, 8)).trim()}...`; + return trimmed; + } + return lines; + } + + function formatTick(value) { + if (Math.abs(value) < 1e-9) return "0"; + return `${value > 0 ? "+" : ""}${chartUtils.format.autoText(value)}`; + } + + function abbrev(label) { + return String(label) + .split(/\s+/) + .filter(Boolean) + .slice(0, 2) + .map(d => d.charAt(0).toUpperCase()) + .join("") + .slice(0, 2) || "S"; + } + + function tint(hex, amount) { + const c = d3.color(hex); + if (!c) return hex; + const r = Math.round(c.r + (255 - c.r) * amount); + const g = Math.round(c.g + (255 - c.g) * amount); + const b = Math.round(c.b + (255 - c.b) * amount); + return `rgb(${r},${g},${b})`; + } +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..2a5816b95b8ac50de5966540035ee568dfb188aa --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_02.js @@ -0,0 +1,678 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], ["-inf", "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["positive", "negative"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const sourceRows = (jsonData.data && jsonData.data.data) ? jsonData.data.data : []; + const variables = jsonData.variables || {}; + const metadata = jsonData.metadata || {}; + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackKey: "category" }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackKey: "value" }); + const categoryField = xChannel.key; + const valueField = yChannel.key; + const unit = yChannel.unit || ""; + + const baseWidth = variables.width || 1024; + const baseHeight = variables.height || 1536; + const width = 1024; + const height = 1536; + const svg = d3.select(containerSelector) + .html("") + .append("svg") + .attr("width", baseWidth) + .attr("height", baseHeight) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "horizontal_diverging_bar_chart_02"); + + const colors = { + navy: "#0a1f46", + navy2: "#12346e", + muted: "#34435a", + lightText: "#637085", + grid: "#d2dae2", + gridDark: "#8b98a7", + green: "#177f42", + greenDark: "#0d6f35", + greenSoft: "#eef8f1", + red: "#ef3d39", + redDark: "#d7191c", + redSoft: "#fff3f1", + paper: "#f8faf8", + panel: "#ffffff" + }; + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", colors.paper); + + const defs = svg.append("defs"); + const softShadow = defs.append("filter") + .attr("id", "hdb02-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "140%"); + softShadow.append("feDropShadow") + .attr("dx", "0") + .attr("dy", "8") + .attr("stdDeviation", "10") + .attr("flood-color", "#0b1f46") + .attr("flood-opacity", "0.10"); + + const positiveGradient = defs.append("linearGradient") + .attr("id", "hdb02-positive-gradient") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + positiveGradient.append("stop").attr("offset", "0%").attr("stop-color", "#106f45"); + positiveGradient.append("stop").attr("offset", "100%").attr("stop-color", "#1b9159"); + + const negativeGradient = defs.append("linearGradient") + .attr("id", "hdb02-negative-gradient") + .attr("x1", "100%") + .attr("x2", "0%") + .attr("y1", "0%") + .attr("y2", "0%"); + negativeGradient.append("stop").attr("offset", "0%").attr("stop-color", "#ff5b55"); + negativeGradient.append("stop").attr("offset", "100%").attr("stop-color", "#d60f12"); + + function temporalKeyFor(value) { + const text = String(value == null ? "" : value).trim(); + const lower = text.toLowerCase(); + const monthIndex = { + jan: 0, january: 0, feb: 1, february: 1, mar: 2, march: 2, + apr: 3, april: 3, may: 4, jun: 5, june: 5, jul: 6, july: 6, + aug: 7, august: 7, sep: 8, sept: 8, september: 8, oct: 9, + october: 9, nov: 10, november: 10, dec: 11, december: 11 + }; + const seasonIndex = { winter: 0, spring: 1, summer: 2, fall: 3, autumn: 3 }; + + let m = lower.match(/^(\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (m) { + return Number(m[1]) * 400 + (Number(m[2]) - 1) * 31 + Number(m[3] || 1); + } + m = lower.match(/^(\d{4})\s*q([1-4])$/) || lower.match(/^q([1-4])\s*(\d{4})$/); + if (m) { + const year = m[2] && m[2].length === 4 ? Number(m[2]) : Number(m[1]); + const quarter = m[2] && m[2].length === 4 ? Number(m[1]) : Number(m[2]); + return year * 400 + (quarter - 1) * 90; + } + m = lower.match(/^([a-z]+)\s+(\d{4})$/) || lower.match(/^(\d{4})\s+([a-z]+)$/); + if (m) { + const year = /^\d{4}$/.test(m[1]) ? Number(m[1]) : Number(m[2]); + const word = /^\d{4}$/.test(m[1]) ? m[2] : m[1]; + if (Object.prototype.hasOwnProperty.call(monthIndex, word)) return year * 400 + monthIndex[word] * 31; + if (Object.prototype.hasOwnProperty.call(seasonIndex, word)) return year * 400 + seasonIndex[word] * 90; + } + if (Object.prototype.hasOwnProperty.call(monthIndex, lower)) return 2000 * 400 + monthIndex[lower] * 31; + if (Object.prototype.hasOwnProperty.call(seasonIndex, lower)) return 2000 * 400 + seasonIndex[lower] * 90; + m = lower.match(/^(\d{4})$/); + if (m) return Number(m[1]) * 400; + return null; + } + + function fieldNameLooksTemporal(name) { + return /(^|[_\s-])(year|date|month|quarter|season|timestamp|time|week|day|period)(s)?($|[_\s-])/i.test(String(name || "")); + } + + const rows = sourceRows + .map((d, index) => ({ + raw: d, + index, + category: String(d[categoryField] == null ? `Item ${index + 1}` : d[categoryField]), + value: +d[valueField], + temporalKey: temporalKeyFor(d[categoryField]) + })) + .filter(d => Number.isFinite(d.value)); + const temporalHitCount = rows.filter(d => d.temporalKey !== null).length; + const usesTemporalOrder = rows.length > 1 && ( + temporalHitCount >= Math.max(2, Math.ceil(rows.length * 0.6)) || + (fieldNameLooksTemporal(categoryField) && temporalHitCount > 0) + ); + svg.attr("data-row-ordering", usesTemporalOrder ? "chronological" : "diverging-value-groups"); + const positives = rows.filter(d => d.value >= 0).sort((a, b) => b.value - a.value); + const negatives = rows.filter(d => d.value < 0).sort((a, b) => b.value - a.value); + const orderedRows = usesTemporalOrder + ? rows.slice().sort((a, b) => (a.temporalKey - b.temporalKey) || (a.index - b.index)) + : positives.concat(negatives); + + function splitWords(text, maxChars, maxLines) { + const words = String(text || "").replace(/\s+/g, " ").trim().split(" ").filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const test = current ? `${current} ${word}` : word; + if (test.length <= maxChars || !current) { + current = test; + } else { + lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + if (maxLines && lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = kept[maxLines - 1].replace(/\.*$/, "") + "..."; + return kept; + } + return lines; + } + + function addWrappedText(parent, text, x, y, options) { + const lineHeight = options.lineHeight || options.fontSize * 1.18; + const lines = splitWords(text, options.maxChars || 48, options.maxLines || 3); + const textNode = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", options.anchor || "start") + .style("font-family", options.fontFamily || "Arial, Helvetica, sans-serif") + .style("font-size", `${options.fontSize}px`) + .style("font-weight", options.fontWeight || 400) + .style("letter-spacing", options.letterSpacing || 0) + .style("fill", options.fill || colors.navy); + lines.forEach((line, i) => { + textNode.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : lineHeight) + .text(line); + }); + return { node: textNode, lines, height: lines.length * lineHeight }; + } + + function valueFmt(value) { + const abs = Math.abs(value); + const decimals = abs >= 20 ? 1 : (abs >= 1 ? 1 : 2); + let out = chartUtils.format.autoText ? chartUtils.format.autoText(value) : value.toFixed(decimals); + if (String(out).indexOf(".") >= 0) out = String(out).replace(/\.0+$/, "").replace(/(\.\d*[1-9])0+$/, "$1"); + return `${value > 0 ? "+" : ""}${out}`; + } + + function metricLabel() { + if (unit === "$b" || unit === "$B") return "BILLION USD"; + if (unit) return unit.toUpperCase(); + return String(valueField || "value").replace(/([a-z])([A-Z])/g, "$1 $2").toUpperCase(); + } + + function axisFmt(value) { + if (Math.abs(value) >= 1000) return chartUtils.format.autoText(value); + if (Math.abs(value) < 1 && value !== 0) return value.toFixed(1).replace(/\.0$/, ""); + return String(Math.round(value * 10) / 10).replace(/\.0$/, ""); + } + + function niceStep(maxAbs) { + if (maxAbs > 200) return 50; + if (maxAbs > 80) return 20; + if (maxAbs > 20) return 10; + if (maxAbs > 5) return 2; + if (maxAbs > 1) return 0.5; + return 0.2; + } + + const minValue = d3.min(rows, d => d.value) || 0; + const maxValue = d3.max(rows, d => d.value) || 0; + const step = niceStep(Math.max(Math.abs(minValue), Math.abs(maxValue))); + let domainMin = minValue < 0 ? Math.floor((minValue * 1.10) / step) * step : 0; + let domainMax = maxValue > 0 ? Math.ceil((maxValue * 1.60) / step) * step : 0; + if (domainMin === 0 && domainMax === 0) { + domainMin = -1; + domainMax = 1; + } else if (domainMin === 0) { + domainMin = -step; + } else if (domainMax === 0) { + domainMax = step; + } + if (maxValue > 0 && minValue < 0 && Math.abs(domainMin) < domainMax * 0.35) { + domainMin = -domainMax * 0.35; + } else if (maxValue > 0 && minValue >= 0) { + domainMin = -domainMax * 0.25; + } + + const x0 = 180; + const x1 = 910; + const xScale = d3.scaleLinear().domain([domainMin, domainMax]).range([x0, x1]); + const zeroX = xScale(0); + const axisY = 1396; + const rowTop = 445; + const chipHeight = 46; + const chipGap = 22; + const chipToRowGap = 26; + const groupGap = !usesTemporalOrder && positives.length && negatives.length ? 28 : 0; + const reservedForChips = usesTemporalOrder ? 0 : ( + (positives.length ? chipHeight + chipToRowGap : 0) + + (negatives.length ? chipHeight + chipToRowGap : 0) + groupGap + ); + const rowStep = Math.max(48, Math.min(84, (axisY - rowTop - reservedForChips - 16) / Math.max(orderedRows.length, 1))); + const bandHeight = Math.max(34, rowStep * 0.72); + const barHeight = Math.max(18, bandHeight * 0.58); + const labelFont = Math.max(17, Math.min(24, rowStep * 0.30)); + const valueFont = Math.max(17, Math.min(30, rowStep * 0.36)); + + const title = metadata.title || jsonData.title || ""; + const titleParts = String(title).split(":"); + const eyebrow = titleParts.length > 1 ? `${titleParts[0].trim()}:` : ""; + const mainTitle = (titleParts.length > 1 ? titleParts.slice(1).join(":") : title).trim(); + const mainSegments = mainTitle.includes(",") + ? mainTitle.split(",").map(s => s.trim()).filter(Boolean) + : splitWords(mainTitle, 20, 3); + + if (eyebrow) { + svg.append("text") + .attr("x", 52) + .attr("y", 78) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "30px") + .style("font-weight", 800) + .style("letter-spacing", "3px") + .style("fill", colors.navy) + .text(eyebrow.toUpperCase()); + } + + const titleY = eyebrow ? 165 : 96; + mainSegments.slice(0, 3).forEach((line, i) => { + svg.append("text") + .attr("x", 52) + .attr("y", titleY + i * (mainSegments.length > 2 ? 58 : 70)) + .style("font-family", "Arial Black, Arial, Helvetica, sans-serif") + .style("font-size", mainSegments.length > 2 ? "48px" : "56px") + .style("font-weight", 900) + .style("letter-spacing", "0") + .style("fill", i === 1 ? colors.green : colors.navy) + .text(line.toUpperCase()); + }); + + const subtitleText = metadata.description || jsonData.description || ""; + addWrappedText(svg, subtitleText, 52, 323, { + fontSize: 24, + lineHeight: 34, + maxChars: 64, + maxLines: 3, + fill: colors.navy, + fontWeight: 400 + }); + + const art = svg.append("g") + .attr("class", "reserved-asset-slot header-trade-art-slot") + .attr("data-asset-slot", "header-thematic-trade-art") + .attr("data-slot-policy", "image2_asset_or_retrieval_owned") + .attr("data-anchor", "top-right-header-safe-area") + .attr("data-collision-rule", "stay-right-of-title-and-above-chart-rows") + .attr("transform", "translate(764,48)"); + art.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", 210) + .attr("height", 180) + .attr("rx", 28) + .attr("fill", "#eef5f8") + .attr("opacity", 0.82); + art.append("circle").attr("cx", 112).attr("cy", 88).attr("r", 66).attr("fill", "#dbe8ef"); + art.append("path") + .attr("d", "M34,126 C78,96 140,154 186,104") + .attr("fill", "none") + .attr("stroke", "#8fb0c2") + .attr("stroke-width", 8) + .attr("stroke-linecap", "round") + .attr("opacity", 0.55); + art.append("rect") + .attr("x", 34) + .attr("y", 58) + .attr("width", 64) + .attr("height", 42) + .attr("rx", 10) + .attr("fill", "#d93b36") + .attr("opacity", 0.88); + art.append("rect") + .attr("x", 128) + .attr("y", 66) + .attr("width", 66) + .attr("height", 40) + .attr("rx", 10) + .attr("fill", "#12346e") + .attr("opacity", 0.88); + art.append("text") + .attr("x", 108) + .attr("y", 148) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "11px") + .style("font-weight", 700) + .style("fill", "#5c6d7c") + .text("RESERVED ART SLOT"); + + svg.append("line") + .attr("x1", 52) + .attr("x2", 972) + .attr("y1", 430) + .attr("y2", 430) + .attr("stroke", colors.grid) + .attr("stroke-width", 2); + + const chartMetric = metricLabel(); + addWrappedText(svg, chartMetric.toUpperCase(), 810, 462, { + fontSize: 17, + lineHeight: 24, + maxChars: 18, + maxLines: 2, + fill: colors.muted, + fontWeight: 700, + anchor: "middle" + }); + + function sectionChip(y, type) { + const isPositive = type === "positive"; + const g = svg.append("g") + .attr("class", `section-chip ${type}`) + .attr("data-section", type); + const x = 58; + const desiredChipW = isPositive ? 500 : 520; + const zeroLineGap = 26; + const maxSafeChipW = Math.max(248, zeroX - x - zeroLineGap); + const chipW = Math.min(desiredChipW, maxSafeChipW); + const detailText = chipW >= 390 + ? (isPositive ? "(positive balance)" : "(negative balance)") + : ""; + const detailX = x + (isPositive ? 210 : 190); + g.append("rect") + .attr("x", x) + .attr("y", y) + .attr("width", chipW) + .attr("height", chipHeight) + .attr("rx", chipHeight / 2) + .attr("fill", isPositive ? "#e0f0df" : "#fde6e3"); + g.append("circle") + .attr("cx", x + 25) + .attr("cy", y + chipHeight / 2) + .attr("r", 24) + .attr("fill", isPositive ? colors.green : colors.red); + g.append("text") + .attr("x", x + 25) + .attr("y", y + chipHeight / 2 + 8) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "28px") + .style("font-weight", 900) + .style("fill", "#ffffff") + .text(isPositive ? "↗" : "↘"); + g.append("text") + .attr("x", x + 82) + .attr("y", y + 31) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "23px") + .style("font-weight", 800) + .style("fill", isPositive ? colors.greenDark : colors.redDark) + .text(isPositive ? "SURPLUS" : "DEFICIT"); + if (detailText) { + g.append("text") + .attr("x", detailX) + .attr("y", y + 31) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "20px") + .style("font-weight", 700) + .style("fill", isPositive ? colors.greenDark : colors.redDark) + .text(detailText); + } + } + + const rowPositions = new Map(); + let cursorY = rowTop; + if (usesTemporalOrder) { + orderedRows.forEach(row => { + rowPositions.set(row.index, cursorY); + cursorY += rowStep; + }); + } else if (positives.length) { + sectionChip(cursorY, "positive"); + cursorY += chipHeight + chipToRowGap; + positives.forEach(row => { + rowPositions.set(row.index, cursorY); + cursorY += rowStep; + }); + } + if (!usesTemporalOrder && negatives.length) { + cursorY += positives.length ? groupGap : 0; + sectionChip(cursorY, "negative"); + cursorY += chipHeight + chipToRowGap; + negatives.forEach(row => { + rowPositions.set(row.index, cursorY); + cursorY += rowStep; + }); + } + + const rowLayer = svg.append("g").attr("class", "diverging-row-layer"); + const labelMaxChars = 18; + orderedRows.forEach(row => { + const y = rowPositions.get(row.index); + const centerY = y + bandHeight / 2; + const rowFill = row.value >= 0 ? colors.greenSoft : colors.redSoft; + rowLayer.append("rect") + .attr("x", 52) + .attr("y", y) + .attr("width", 920) + .attr("height", bandHeight) + .attr("rx", 11) + .attr("fill", rowFill) + .attr("opacity", 0.82) + .attr("data-row-category", row.category); + rowLayer.append("line") + .attr("x1", 52) + .attr("x2", 972) + .attr("y1", y + bandHeight) + .attr("y2", y + bandHeight) + .attr("stroke", "#e1e5e8") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 4"); + + const slot = rowLayer.append("g") + .attr("class", "reserved-asset-slot category-icon-slot") + .attr("data-asset-slot", "category-icon") + .attr("data-slot-policy", "input_provided_or_image2_asset") + .attr("data-anchor", "row-centerline-left-label-column") + .attr("data-collision-rule", "centerline-align-with-row-without-overlapping-labels-or-bars") + .attr("data-category", row.category); + slot.append("circle") + .attr("cx", 92) + .attr("cy", centerY) + .attr("r", Math.min(29, bandHeight * 0.42)) + .attr("fill", colors.panel) + .attr("stroke", row.value >= 0 ? "#b7d9c2" : "#efb8b5") + .attr("stroke-width", 2.5); + slot.append("text") + .attr("x", 92) + .attr("y", centerY + 8) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", `${Math.min(22, labelFont)}px`) + .style("font-weight", 800) + .style("fill", row.value >= 0 ? colors.green : colors.red) + .text(row.category.slice(0, 1).toUpperCase()); + + const smallNegativeNearZero = row.value < 0 && Math.abs(xScale(row.value) - zeroX) < 52 && zeroX < 430; + const rowLabelMaxChars = smallNegativeNearZero ? 12 : labelMaxChars; + const labelLines = splitWords(row.category, rowLabelMaxChars, 2); + const labelText = rowLayer.append("text") + .attr("x", 142) + .attr("y", centerY - ((labelLines.length - 1) * labelFont * 0.56)) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", `${labelFont}px`) + .style("font-weight", 800) + .style("fill", colors.navy); + labelLines.forEach((line, i) => { + labelText.append("tspan") + .attr("x", 142) + .attr("dy", i === 0 ? 0 : labelFont * 1.12) + .text(line); + }); + }); + + const plotLayer = svg.append("g").attr("class", "diverging-plot-layer"); + const firstRowY = orderedRows.length ? d3.min(orderedRows, row => rowPositions.get(row.index)) : rowTop; + plotLayer.append("line") + .attr("x1", zeroX) + .attr("x2", zeroX) + .attr("y1", firstRowY + 6) + .attr("y2", axisY) + .attr("stroke", "#26384c") + .attr("stroke-width", 2.2) + .attr("opacity", 0.85) + .attr("data-axis-role", "zero-line"); + + orderedRows.forEach(row => { + const y = rowPositions.get(row.index); + const centerY = y + bandHeight / 2; + const barY = centerY - barHeight / 2; + const endX = xScale(row.value); + const barX = Math.min(zeroX, endX); + const barW = Math.max(1, Math.abs(endX - zeroX)); + const gradient = row.value >= 0 ? "url(#hdb02-positive-gradient)" : "url(#hdb02-negative-gradient)"; + plotLayer.append("rect") + .attr("x", barX) + .attr("y", barY) + .attr("width", barW) + .attr("height", barHeight) + .attr("rx", 7) + .attr("fill", gradient) + .attr("filter", "url(#hdb02-soft-shadow)") + .attr("data-category", row.category) + .attr("data-value", row.value) + .attr("data-mark-role", "diverging-bar"); + + const text = valueFmt(row.value); + let valueFontForRow = valueFont; + function measureValueText(fontSize) { + return chartUtils.text.measure(plotLayer, text, { + fontFamily: "Arial, Helvetica, sans-serif", + fontSize: `${fontSize}px`, + fontWeight: 900 + }).width; + } + let endpointTextWidth = measureValueText(valueFontForRow); + const textGap = 12; + let valueX = row.value >= 0 ? endX + textGap : endX - textGap; + let anchor = row.value >= 0 ? "start" : "end"; + let labelInsideBar = false; + let compactNegativePill = null; + if (row.value >= 0 && valueX > 960) { + valueX = endX - textGap; + anchor = "end"; + labelInsideBar = true; + } + if (row.value < 0 && valueX < 306 && barW > endpointTextWidth + 24) { + valueX = barX + textGap; + anchor = "start"; + labelInsideBar = true; + } + if (row.value < 0 && !labelInsideBar && valueX - endpointTextWidth < 330 && barW > endpointTextWidth + 24) { + valueX = barX + textGap; + anchor = "start"; + labelInsideBar = true; + } + if (row.value < 0 && !labelInsideBar && valueX - endpointTextWidth < 330) { + valueFontForRow = Math.max(15, valueFont * 0.78); + endpointTextWidth = measureValueText(valueFontForRow); + const pillPadX = 8; + const pillW = endpointTextWidth + pillPadX * 2; + const pillRight = zeroX - 8; + const pillH = valueFontForRow * 1.18; + compactNegativePill = { + x: pillRight - pillW, + y: centerY - pillH / 2, + width: pillW, + height: pillH, + rx: Math.min(7, pillH / 2) + }; + valueX = pillRight - pillPadX; + anchor = "end"; + labelInsideBar = true; + } + if (compactNegativePill) { + plotLayer.append("rect") + .attr("x", compactNegativePill.x) + .attr("y", compactNegativePill.y) + .attr("width", compactNegativePill.width) + .attr("height", compactNegativePill.height) + .attr("rx", compactNegativePill.rx) + .attr("fill", colors.redDark) + .attr("data-label-role", "negative-value-pill"); + } + plotLayer.append("text") + .attr("x", valueX) + .attr("y", centerY + valueFontForRow * 0.36) + .attr("text-anchor", anchor) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", `${valueFontForRow}px`) + .style("font-weight", 900) + .style("fill", labelInsideBar ? "#ffffff" : (row.value >= 0 ? "#176ecf" : colors.redDark)) + .attr("data-label-role", "value-label") + .text(text); + }); + + const tickValues = xScale.ticks(6).filter(t => t >= domainMin - 1e-9 && t <= domainMax + 1e-9); + const axisLayer = svg.append("g") + .attr("class", "bottom-axis") + .attr("data-axis-role", "bottom-value-axis"); + axisLayer.append("line") + .attr("x1", x0) + .attr("x2", x1) + .attr("y1", axisY) + .attr("y2", axisY) + .attr("stroke", "#33465a") + .attr("stroke-width", 1.7); + tickValues.forEach(t => { + const tx = xScale(t); + axisLayer.append("line") + .attr("x1", tx) + .attr("x2", tx) + .attr("y1", axisY) + .attr("y2", axisY + 10) + .attr("stroke", "#33465a") + .attr("stroke-width", 1.4); + axisLayer.append("text") + .attr("x", tx) + .attr("y", axisY + 34) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "18px") + .style("font-weight", 500) + .style("fill", colors.navy) + .text(axisFmt(t)); + }); + axisLayer.append("text") + .attr("x", (x0 + x1) / 2) + .attr("y", axisY + 72) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "20px") + .style("font-weight", 600) + .style("letter-spacing", "1px") + .style("fill", colors.muted) + .text(metricLabel()); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_03.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_03.js new file mode 100644 index 0000000000000000000000000000000000000000..0b88258b649f915a725d36e9f7efcb744321d74f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_03.js @@ -0,0 +1,718 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_03", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], ["-inf", "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary","secondary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const chartDataRaw = (jsonData.data && jsonData.data.data) || []; + const colorResolver = chartUtils.color.resolver(jsonData); + const typography = jsonData.typography || {}; + const variables = jsonData.variables || {}; + const images = jsonData.images || { field: {}, other: {} }; + + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const dataColumns = chartUtils.schema.columns(jsonData); + const dimensionColumn = dataColumns.find(c => c.name === dimensionField) || {}; + const valueUnit = valueChannel.unit || ""; + const valueFieldName = valueChannel.key || valueField || "Value"; + const dimensionFieldName = dimensionChannel.key || dimensionField || "Category"; + + d3.select(containerSelector).html(""); + + const width = Math.max(520, variables.width || 600); + const height = Math.max(820, variables.height || Math.round(width * 1.48)); + const titleText = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || ""; + const subtitleText = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || ""; + + const isTemporal = dimensionColumn.data_type === "temporal" || + chartDataRaw.every(d => /^\d{4}$/.test(String(d[dimensionField]))); + const parseTemporal = value => { + const raw = String(value); + if (/^\d{4}$/.test(raw)) return +raw; + const parsed = Date.parse(raw); + return Number.isFinite(parsed) ? parsed : raw; + }; + const chartData = chartDataRaw + .filter(d => d && d[dimensionField] !== undefined && d[valueField] !== undefined) + .map((d, index) => ({ ...d, __inputIndex: index, __value: +d[valueField] || 0 })) + .sort((a, b) => { + if (!isTemporal) return a.__inputIndex - b.__inputIndex; + const av = parseTemporal(a[dimensionField]); + const bv = parseTemporal(b[dimensionField]); + if (typeof av === "number" && typeof bv === "number") return av - bv; + return String(a[dimensionField]).localeCompare(String(b[dimensionField])); + }); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("style", "max-width: 100%; height: auto;"); + + const defs = svg.append("defs"); + const positiveBase = "#b01818"; + const negativeBase = "#1f72d2"; + const textColor = colorResolver.text({ fallback: "#343434" }).value || "#343434"; + const mutedText = "#58606a"; + const gridColor = "#d8d2cf"; + + const bgGradient = defs.append("linearGradient") + .attr("id", "hdbc03-background") + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "100%").attr("y2", "0%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#f8fcfd"); + bgGradient.append("stop").attr("offset", "48%").attr("stop-color", "#fffaf8"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#fff7f3"); + + const positiveGradient = defs.append("linearGradient") + .attr("id", "hdbc03-positive") + .attr("x1", "0%").attr("x2", "100%") + .attr("y1", "0%").attr("y2", "0%"); + positiveGradient.append("stop").attr("offset", "0%").attr("stop-color", colorResolver.variant(positiveBase, { mode: "brighter", amount: 0.18 })); + positiveGradient.append("stop").attr("offset", "100%").attr("stop-color", colorResolver.variant(positiveBase, { mode: "darker", amount: 0.08 })); + + const negativeGradient = defs.append("linearGradient") + .attr("id", "hdbc03-negative") + .attr("x1", "100%").attr("x2", "0%") + .attr("y1", "0%").attr("y2", "0%"); + negativeGradient.append("stop").attr("offset", "0%").attr("stop-color", colorResolver.variant(negativeBase, { mode: "brighter", amount: 0.18 })); + negativeGradient.append("stop").attr("offset", "100%").attr("stop-color", colorResolver.variant(negativeBase, { mode: "darker", amount: 0.08 })); + + const shadow = defs.append("filter") + .attr("id", "hdbc03-soft-shadow") + .attr("x", "-20%").attr("y", "-20%") + .attr("width", "140%").attr("height", "140%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 2) + .attr("stdDeviation", 3) + .attr("flood-color", "#21110e") + .attr("flood-opacity", 0.14); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#hdbc03-background)") + .attr("fill-opacity", 0.62); + + const titleFont = typography.title || {}; + const labelFont = typography.label || {}; + const annotationFont = typography.annotation || {}; + const titleFamily = titleFont.font_family || "Georgia, 'Times New Roman', serif"; + const sansFamily = labelFont.font_family || "Arial, Helvetica, sans-serif"; + + function measure(text, fontSize, fontWeight = 400, fontFamily = sansFamily) { + return chartUtils.text.measure(svg, String(text), { + fontFamily, + fontSize: `${fontSize}px`, + fontWeight + }).width; + } + + function humanizeLabel(text) { + return String(text == null ? "" : text) + .replace(/_/g, " ") + .replace(/([a-z0-9])([A-Z])/g, "$1 $2") + .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2") + .replace(/\s*-\s*/g, " - ") + .replace(/\s+/g, " ") + .trim(); + } + + function compactFieldLabel(text) { + return humanizeLabel(text) + .replace(/\bTemperature\b/gi, "Temp.") + .replace(/\bDifferential\b/gi, "Diff.") + .replace(/\bAnomaly\b/gi, "Anomaly") + .replace(/\bBalance\b/gi, "Balance"); + } + + function addWrappedText(parent, text, x, y, maxWidth, options) { + const cfg = { + fontFamily: sansFamily, + fontSize: 16, + fontWeight: 400, + fill: textColor, + anchor: "middle", + lineHeight: 1.18, + maxLines: 2, + textTransform: value => value, + ...options + }; + const source = cfg.textTransform(String(text || "")); + const words = source.split(/\s+/).filter(Boolean); + const el = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", cfg.anchor) + .style("font-family", cfg.fontFamily) + .style("font-size", `${cfg.fontSize}px`) + .style("font-weight", cfg.fontWeight) + .style("fill", cfg.fill); + const lines = []; + let line = []; + words.forEach(word => { + const candidate = [...line, word].join(" "); + if (line.length && measure(candidate, cfg.fontSize, cfg.fontWeight, cfg.fontFamily) > maxWidth) { + lines.push(line.join(" ")); + line = [word]; + } else { + line.push(word); + } + }); + if (line.length) lines.push(line.join(" ")); + const visible = lines.slice(0, cfg.maxLines); + if (lines.length > cfg.maxLines && visible.length) { + let last = visible[visible.length - 1]; + while (last.length > 4 && measure(`${last}...`, cfg.fontSize, cfg.fontWeight, cfg.fontFamily) > maxWidth) { + last = last.split(/\s+/).slice(0, -1).join(" "); + } + visible[visible.length - 1] = `${last}...`; + } + visible.forEach((lineText, i) => { + el.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : `${cfg.lineHeight}em`) + .text(lineText); + }); + return el; + } + + function formatValue(value, opts = {}) { + const abs = Math.abs(value); + let text; + if (abs >= 1000000) { + text = `${chartUtils.format.autoText(value / 1000000)}M`; + } else if (abs >= 1000) { + text = `${chartUtils.format.autoText(value / 1000)}K`; + } else { + text = chartUtils.format.autoText(value); + } + const sign = value > 0 ? "+" : ""; + const suffix = opts.omitUnit ? "" : valueUnit; + return `${sign}${text}${suffix}`; + } + + function tickLabel(value, sign) { + const text = formatValue(value, { omitUnit: false }).replace(/^\+/, ""); + return sign < 0 ? `-${text}` : `+${text}`; + } + + function buildTickValues(maxValue, sideSpan) { + if (maxValue <= 2 && sideSpan >= 180) { + const smallStep = maxValue <= 1 ? 0.2 : 0.2; + return d3.range(smallStep, maxValue + smallStep / 2, smallStep); + } + let target = Math.max(2, Math.min(6, Math.floor(sideSpan / 58))); + let values = []; + while (target >= 2) { + const step = d3.tickStep(0, maxValue, target); + values = d3.range(step, maxValue + step / 2, step); + const minGap = values.length > 1 ? sideSpan / values.length : sideSpan; + const maxLabelWidth = d3.max(values, value => Math.max( + measure(tickLabel(value, -1), 10, 600), + measure(tickLabel(value, 1), 10, 600) + )) || 0; + if (values.length <= 2 || maxLabelWidth + 12 <= minGap) break; + target -= 1; + } + return values; + } + + const rows = chartData; + const rowCount = Math.max(1, rows.length); + const outerMargin = { left: 42, right: 42 }; + const plotTop = 275; + const plotBottom = height - 92; + const plotHeight = Math.max(360, plotBottom - plotTop); + const rowBand = plotHeight / rowCount; + const rowGap = Math.max(3, Math.min(8, rowBand * 0.16)); + const barHeight = Math.max(10, rowBand - rowGap); + + const labelWidths = rows.map(d => measure(d[dimensionField], 21, 600)); + const centerBoxMaxWidth = isTemporal ? width * 0.18 : width * 0.32; + const centerBoxWidth = Math.max(64, Math.min(centerBoxMaxWidth, d3.max(labelWidths) + 24)); + const centerBoxLeft = width / 2 - centerBoxWidth / 2; + const centerBoxRight = centerBoxLeft + centerBoxWidth; + const leftBound = outerMargin.left; + const rightBound = width - outerMargin.right; + const availableLeft = centerBoxLeft - leftBound; + const availableRight = rightBound - centerBoxRight; + const sideWidth = Math.max(40, Math.min(availableLeft, availableRight)); + const chartLeft = centerBoxLeft - sideWidth; + const chartRight = centerBoxRight + sideWidth; + + const valueLabelSize = Math.max(12, Math.min(16, rowBand * 0.42)); + const maxPositiveLabelWidth = d3.max(rows.filter(d => d.__value >= 0), d => measure(formatValue(d.__value), valueLabelSize, 700)) || 0; + const maxNegativeLabelWidth = d3.max(rows.filter(d => d.__value < 0), d => measure(formatValue(d.__value), valueLabelSize, 700)) || 0; + const endpointGap = 10; + const maxAbsRaw = d3.max(rows, d => Math.abs(d.__value)) || 1; + const reserveCapRatio = maxAbsRaw <= 2 ? 0.26 : 0.38; + const positiveLabelReserve = Math.min(sideWidth * reserveCapRatio, Math.max(40, maxPositiveLabelWidth + endpointGap + 10)); + const negativeLabelReserve = Math.min(sideWidth * reserveCapRatio, Math.max(40, maxNegativeLabelWidth + endpointGap + 10)); + const markSideWidth = Math.max(40, sideWidth - Math.max(positiveLabelReserve, negativeLabelReserve)); + const rightLabelLimit = width - 12; + const leftLabelLimit = 12; + + const niceMaxAbs = Math.max(1, Math.ceil(maxAbsRaw * 5) / 5); + const magnitudeScale = d3.scaleLinear() + .domain([0, niceMaxAbs]) + .range([0, markSideWidth]); + const maxAbs = magnitudeScale.domain()[1]; + const tickValues = buildTickValues(maxAbs, sideWidth); + + const plot = svg.append("g").attr("class", "hdbc03-plot"); + const tickY = plotTop - 32; + const headingY = plotTop - 78; + + function addAssetChip(slotName, x, y, sideColor, symbol) { + const g = svg.append("g") + .attr("class", `asset-slot ${slotName}`) + .attr("data-asset-slot", slotName) + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-anchor", sideColor === positiveBase ? "right scale heading" : "left scale heading") + .attr("data-collision-rule", "avoid heading text and tick labels"); + g.append("circle") + .attr("cx", x) + .attr("cy", y) + .attr("r", 19) + .attr("fill", colorResolver.variant(sideColor, { mode: "brighter", amount: 0.78 })) + .attr("stroke", colorResolver.variant(sideColor, { mode: "brighter", amount: 0.25 })) + .attr("stroke-width", 1); + g.append("text") + .attr("x", x) + .attr("y", y + 1) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", sansFamily) + .style("font-size", "20px") + .style("font-weight", 700) + .style("fill", sideColor) + .text(symbol); + } + + addAssetChip("negative-heading-icon", chartLeft + 20, headingY + 6, negativeBase, "-"); + addAssetChip("positive-heading-icon", chartRight - 20, headingY + 6, positiveBase, "+"); + + addWrappedText(svg, "BELOW AVERAGE", chartLeft + sideWidth * 0.58, headingY, sideWidth * 0.72, { + fontFamily: sansFamily, + fontSize: 14, + fontWeight: 700, + fill: negativeBase, + anchor: "middle", + maxLines: 2, + lineHeight: 0.95 + }); + addWrappedText(svg, "ABOVE AVERAGE", centerBoxRight + sideWidth * 0.42, headingY, sideWidth * 0.72, { + fontFamily: sansFamily, + fontSize: 14, + fontWeight: 700, + fill: positiveBase, + anchor: "middle", + maxLines: 2, + lineHeight: 0.95 + }); + const compactMeasure = `${compactFieldLabel(valueFieldName)}${valueUnit ? ` (${valueUnit})` : ""}`; + addWrappedText(svg, compactMeasure, chartLeft + sideWidth * 0.58, headingY + 33, sideWidth * 0.72, { + fontFamily: sansFamily, + fontSize: 11, + fontWeight: 500, + fill: mutedText, + anchor: "middle", + maxLines: 2, + lineHeight: 1.05 + }); + addWrappedText(svg, compactMeasure, centerBoxRight + sideWidth * 0.42, headingY + 33, sideWidth * 0.72, { + fontFamily: sansFamily, + fontSize: 11, + fontWeight: 500, + fill: mutedText, + anchor: "middle", + maxLines: 2, + lineHeight: 1.05 + }); + + tickValues.forEach(value => { + const dx = magnitudeScale(value); + const leftX = centerBoxLeft - dx; + const rightX = centerBoxRight + dx; + plot.append("line") + .attr("x1", leftX) + .attr("x2", leftX) + .attr("y1", plotTop) + .attr("y2", plotBottom) + .attr("stroke", gridColor) + .attr("stroke-width", 0.7) + .attr("stroke-dasharray", "3 4"); + plot.append("line") + .attr("x1", rightX) + .attr("x2", rightX) + .attr("y1", plotTop) + .attr("y2", plotBottom) + .attr("stroke", gridColor) + .attr("stroke-width", 0.7) + .attr("stroke-dasharray", "3 4"); + plot.append("text") + .attr("x", leftX) + .attr("y", tickY) + .attr("text-anchor", "middle") + .style("font-family", sansFamily) + .style("font-size", "8.5px") + .style("font-weight", 600) + .style("fill", negativeBase) + .text(tickLabel(value, -1)); + plot.append("text") + .attr("x", rightX) + .attr("y", tickY) + .attr("text-anchor", "middle") + .style("font-family", sansFamily) + .style("font-size", "8.5px") + .style("font-weight", 600) + .style("fill", positiveBase) + .text(tickLabel(value, 1)); + }); + + plot.append("line") + .attr("x1", chartLeft) + .attr("x2", chartRight) + .attr("y1", plotTop - 8) + .attr("y2", plotTop - 8) + .attr("stroke", "#dfd5d1") + .attr("stroke-width", 0.8); + + const center = plot.append("g").attr("class", "hdbc03-center-column"); + center.append("rect") + .attr("x", centerBoxLeft) + .attr("y", plotTop - 26) + .attr("width", centerBoxWidth) + .attr("height", plotHeight + 26) + .attr("rx", 14) + .attr("fill", "rgba(255,255,255,0.72)") + .attr("stroke", "#d6d0ce") + .attr("filter", "url(#hdbc03-soft-shadow)"); + center.append("text") + .attr("x", centerBoxLeft + centerBoxWidth / 2) + .attr("y", plotTop - 8) + .attr("text-anchor", "middle") + .style("font-family", sansFamily) + .style("font-size", "16px") + .style("font-weight", 700) + .style("fill", "#4a4a4a") + .text(humanizeLabel(dimensionFieldName || "YEAR").toUpperCase()); + + rows.forEach((d, index) => { + const y0 = plotTop + index * rowBand; + center.append("line") + .attr("x1", centerBoxLeft) + .attr("x2", centerBoxRight) + .attr("y1", y0) + .attr("y2", y0) + .attr("stroke", "#dcd6d3") + .attr("stroke-width", 0.75); + }); + center.append("line") + .attr("x1", centerBoxLeft) + .attr("x2", centerBoxRight) + .attr("y1", plotBottom) + .attr("y2", plotBottom) + .attr("stroke", "#dcd6d3") + .attr("stroke-width", 0.75); + + const barLayer = plot.append("g").attr("class", "hdbc03-bars"); + const labelLayer = plot.append("g").attr("class", "hdbc03-labels"); + const occupiedBoxes = []; + + function addRowLabel(parent, text, x, cy, maxWidth, fontSize) { + const words = String(text).split(/\s+/).filter(Boolean); + const lines = []; + let line = ""; + words.forEach(token => { + const candidate = line ? `${line} ${token}` : token; + if (line && measure(candidate, fontSize, 600, sansFamily) > maxWidth) { + lines.push(line.trim()); + line = token.trim(); + } else { + line = candidate; + } + }); + if (line) lines.push(line.trim()); + const visible = lines.slice(0, 2); + if (lines.length > 2 && visible.length) { + let last = visible[visible.length - 1]; + while (last.length > 3 && measure(`${last}...`, fontSize, 600, sansFamily) > maxWidth) { + last = last.slice(0, -1); + } + visible[visible.length - 1] = `${last}...`; + } + const textEl = parent.append("text") + .attr("x", x) + .attr("y", cy - ((visible.length - 1) * fontSize * 0.56)) + .attr("text-anchor", "middle") + .style("font-family", sansFamily) + .style("font-size", `${fontSize}px`) + .style("font-weight", 600) + .style("fill", "#3f4146"); + visible.forEach((lineText, i) => { + textEl.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? "0.35em" : "1.05em") + .text(lineText); + }); + } + + rows.forEach((d, index) => { + const rawValue = d.__value; + const isPositive = rawValue >= 0; + const y = plotTop + index * rowBand + rowGap / 2; + const cy = y + barHeight / 2; + const barWidth = Math.max(2, magnitudeScale(Math.abs(rawValue))); + const x = isPositive ? centerBoxRight : centerBoxLeft - barWidth; + const fill = isPositive ? "url(#hdbc03-positive)" : "url(#hdbc03-negative)"; + const radius = Math.min(barHeight / 2, 14); + + const path = isPositive + ? `M ${centerBoxRight},${y} L ${x + barWidth - radius},${y} a ${radius},${radius} 0 0 1 0,${barHeight} L ${centerBoxRight},${y + barHeight} Z` + : `M ${centerBoxLeft},${y} L ${x + radius},${y} a ${radius},${radius} 0 0 0 0,${barHeight} L ${centerBoxLeft},${y + barHeight} Z`; + + barLayer.append("path") + .attr("d", path) + .attr("fill", fill) + .attr("data-category", d[dimensionField]) + .attr("data-value", rawValue) + .attr("data-sample-index", d.__inputIndex) + .attr("stroke", variables.has_stroke ? "rgba(255,255,255,0.7)" : "none") + .attr("stroke-width", variables.has_stroke ? 0.8 : 0); + + addRowLabel( + center, + humanizeLabel(d[dimensionField]), + centerBoxLeft + centerBoxWidth / 2, + cy, + centerBoxWidth - 12, + Math.max(10, Math.min(isTemporal ? 21 : 13, rowBand * (isTemporal ? 0.46 : 0.34))) + ); + + const valueText = formatValue(rawValue); + const labelSize = valueLabelSize; + const labelWidth = measure(valueText, labelSize, 700); + const gap = endpointGap; + const centerClearance = Math.max(12, Math.min(18, barHeight * 0.22)); + const endpointX = isPositive ? centerBoxRight + barWidth : centerBoxLeft - barWidth; + const shortBar = barWidth < labelWidth + gap * 2 + centerClearance; + let labelX; + let anchor; + let labelInside = false; + let labelHalo = false; + if (isPositive) { + const outsideStart = Math.max(endpointX + gap, centerBoxRight + centerClearance); + const safeOutsideStart = Math.min(outsideStart, Math.max(centerBoxRight + centerClearance, rightLabelLimit - labelWidth)); + const outsideFits = safeOutsideStart + labelWidth <= rightLabelLimit && safeOutsideStart >= endpointX + Math.max(2, gap * 0.45); + if (outsideFits || shortBar) { + labelX = outsideFits ? safeOutsideStart : Math.max(centerBoxRight + centerClearance, rightLabelLimit - labelWidth); + anchor = "start"; + labelInside = false; + labelHalo = true; + } else { + labelX = Math.min(chartRight - 2, endpointX - gap); + anchor = "end"; + labelInside = true; + } + } else { + const outsideEnd = Math.min(endpointX - gap, centerBoxLeft - centerClearance); + const safeOutsideEnd = Math.max(outsideEnd, Math.min(centerBoxLeft - centerClearance, leftLabelLimit + labelWidth)); + const outsideFits = safeOutsideEnd - labelWidth >= leftLabelLimit && safeOutsideEnd <= endpointX - Math.max(2, gap * 0.45); + if (outsideFits || shortBar) { + labelX = outsideFits ? safeOutsideEnd : Math.min(centerBoxLeft - centerClearance, leftLabelLimit + labelWidth); + anchor = "end"; + labelInside = false; + labelHalo = true; + } else { + labelX = Math.max(chartLeft + 2, endpointX + gap); + anchor = "start"; + labelInside = true; + } + } + labelLayer.append("text") + .attr("x", labelX) + .attr("y", cy) + .attr("dy", "0.35em") + .attr("text-anchor", anchor) + .style("font-family", annotationFont.font_family || sansFamily) + .style("font-size", `${labelSize}px`) + .style("font-weight", 700) + .style("paint-order", labelHalo ? "stroke" : null) + .style("stroke", labelHalo ? "#fffaf7" : null) + .style("stroke-width", labelHalo ? "3px" : null) + .style("stroke-linejoin", labelHalo ? "round" : null) + .style("fill", labelInside ? "#fff7f2" : (isPositive ? positiveBase : negativeBase)) + .text(valueText); + + occupiedBoxes.push({ + x: Math.min(x, labelX - labelWidth), + y, + w: Math.max(barWidth, Math.abs(labelX - x) + labelWidth), + h: barHeight + }); + }); + + function boxesOverlap(a, b, pad = 0) { + return !(a.x + a.w + pad < b.x || b.x + b.w + pad < a.x || a.y + a.h + pad < b.y || b.y + b.h + pad < a.y); + } + + const imageHref = images.other && images.other.primary; + const rawImagePolicy = images.other && ( + images.other.primary_source_policy || + images.other.primarySourcePolicy || + images.other.source_policy || + images.other.sourcePolicy || + images.other.asset_source_policy || + images.other.assetSourcePolicy + ); + const normalizedImagePolicy = String(rawImagePolicy || "").toLowerCase().replace(/-/g, "_"); + const classifiedImagePolicy = normalizedImagePolicy.includes("input") + ? "input_asset" + : (normalizedImagePolicy.includes("retrieval") + ? "retrieval_asset" + : (normalizedImagePolicy.includes("image2") ? "image2_asset" : "")); + const canRenderClassifiedImage = Boolean(imageHref && classifiedImagePolicy); + const slotW = Math.min(sideWidth * 0.96, width * 0.39); + let slotH = Math.min(slotW * 1.10, height * 0.34); + let slotX = chartLeft + sideWidth * 0.02; + let slotY = plotTop + plotHeight * 0.43; + slotH = Math.min(slotH, Math.max(124, plotBottom - slotY - 10)); + const proposedSlot = { x: slotX, y: slotY, w: slotW, h: slotH }; + let collides = occupiedBoxes.some(box => boxesOverlap(proposedSlot, box, 8)); + if (collides) { + slotY = plotTop + plotHeight * 0.50; + proposedSlot.y = slotY; + collides = occupiedBoxes.some(box => boxesOverlap(proposedSlot, box, 8)); + } + function addNeutralContextSlot(visible) { + const slot = svg.append("g") + .attr("class", "asset-slot context-image-slot") + .attr("data-asset-slot", "context-image") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-slot-policy", "neutral_placeholder_or_image2_asset") + .attr("data-reserved-slot", "context_image_slot") + .attr("data-anchor", "negative-side lower plot area") + .attr("data-collision-rule", "avoid bars, value labels, center column, heading/tick rows, and chart edges") + .attr("data-bbox", `${slotX.toFixed(2)},${slotY.toFixed(2)},${slotW.toFixed(2)},${slotH.toFixed(2)}`) + .attr("data-mask-policy", "downstream image2 may replace only within this rounded bbox") + .attr("data-collision-result", visible ? "visible_clear" : "hidden_due_to_collision_or_insufficient_space"); + if (visible) { + slot.attr("opacity", 0.76); + } + if (!visible) { + slot.append("rect") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 18) + .attr("fill", "none") + .attr("stroke", "none"); + return; + } + const strokeWidth = Math.max(1.4, Math.min(2.4, slotW * 0.014)); + slot.append("rect") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 18) + .attr("fill", "#ffffff") + .attr("fill-opacity", 0.20) + .attr("stroke", "#91A5B0") + .attr("stroke-width", strokeWidth) + .attr("stroke-dasharray", `${Math.max(7, slotW * 0.05)} ${Math.max(6, slotW * 0.04)}`); + slot.append("rect") + .attr("x", slotX + slotW * 0.18) + .attr("y", slotY + slotH * 0.18) + .attr("width", slotW * 0.64) + .attr("height", slotH * 0.64) + .attr("rx", 14) + .attr("fill", "none") + .attr("stroke", "#91A5B0") + .attr("stroke-width", Math.max(1.1, strokeWidth * 0.75)) + .attr("opacity", 0.42); + slot.append("path") + .attr("d", `M ${slotX + slotW * 0.26},${slotY + slotH * 0.68} L ${slotX + slotW * 0.42},${slotY + slotH * 0.50} L ${slotX + slotW * 0.56},${slotY + slotH * 0.61} L ${slotX + slotW * 0.74},${slotY + slotH * 0.38}`) + .attr("fill", "none") + .attr("stroke", "#91A5B0") + .attr("stroke-width", Math.max(1.2, strokeWidth * 0.9)) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round") + .attr("opacity", 0.44); + slot.append("circle") + .attr("cx", slotX + slotW * 0.35) + .attr("cy", slotY + slotH * 0.34) + .attr("r", Math.min(slotW, slotH) * 0.055) + .attr("fill", "#91A5B0") + .attr("opacity", 0.42); + } + + if (canRenderClassifiedImage && !collides && slotY + slotH < plotBottom - 4) { + const clipId = "hdbc03-context-image-clip"; + defs.append("clipPath").attr("id", clipId) + .append("rect") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 18); + const slot = svg.append("g") + .attr("class", "asset-slot context-image-slot") + .attr("data-asset-slot", "context-image") + .attr("data-asset-source-policy", classifiedImagePolicy) + .attr("data-slot-policy", `${classifiedImagePolicy}_or_image2_asset`) + .attr("data-reserved-slot", "context_image_slot") + .attr("data-anchor", "negative-side lower plot area") + .attr("data-collision-rule", "avoid bars, value labels, center column, heading/tick rows, and chart edges") + .attr("data-bbox", `${slotX.toFixed(2)},${slotY.toFixed(2)},${slotW.toFixed(2)},${slotH.toFixed(2)}`) + .attr("data-mask-policy", "visible image clipped to this rounded bbox; downstream image2 may replace only within bbox") + .attr("data-collision-result", "visible_clear"); + slot.append("image") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("preserveAspectRatio", "xMidYMid slice") + .attr("href", imageHref) + .attr("clip-path", `url(#${clipId})`) + .attr("opacity", 0.78); + } else { + addNeutralContextSlot(!collides && slotY + slotH < plotBottom - 4); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04.js new file mode 100644 index 0000000000000000000000000000000000000000..f06fa4c0ba073dee5e6d68696edb9ccf4210f2f0 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04.js @@ -0,0 +1,576 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Diverging Bar Chart", + "chart_name": "diverging_bar_plain_chart_03", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平对比型条形图实现 - 使用D3.js horizontal_split_bar_chart_01 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; // 图表总宽度 + const height = variables.height; // 图表总高度 + // 边距：top-顶部，right-右侧，bottom-底部，left-左侧 + const margin = { top: 100, right: 70, bottom: 40, left: 70 }; + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; // 绘图区宽度 + const innerHeight = height - margin.top - margin.bottom; // 绘图区高度 + + // 设置各部分位置参数 + const centerX = margin.left + innerWidth / 2; // 图表中心X坐标 + const topAreaHeight = 60; // 标题和标签区域高度 + const barPadding = 8; // 条形图之间的间距 + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit!== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对维度进行排序，直接使用原始顺序 + const dimensions = [...allDimensions]; + + // 使用前两个分组作为左右两侧显示数据 + const leftGroup = groups[0]; // 左侧分组 + const rightGroup = groups[1]; // 右侧分组 + + // 如果存在第三个分组，可以用作总计分组（用于显示右侧的总数值） + const totalGroup = groups.length > 2 ? groups[2] : null; + + // ---------- 5. 动态计算维度标签区域宽度 ---------- + + // Check if we should show icons along with text + const showIcons = jsonData.variation?.axis_label === "side"; + // 标志尺寸 + const flagWidth = 20; + const flagHeight = 15; + const flagPadding = 0; + + // 计算最大标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = showIcons ? flagWidth + flagPadding + textWidth : textWidth + 5; + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 为计算出的宽度添加边距，确保有足够空间 + const dimensionLabelWidth = Math.max(maxLabelWidth + 5, 80); // 最小值为80像素 + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + if (variables.has_gradient) { + const leftGradientId = `gradient-${leftGroup.replace(/\s+/g, '-').toLowerCase()}`; + const leftBaseColor = getColor(leftGroup); + + const leftGradient = defs.append("linearGradient") + .attr("id", leftGradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + leftGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(leftBaseColor, { mode: "brighter", amount: 1.2 })); + + leftGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(leftBaseColor, { mode: "darker", amount: 0.7 })); + + const rightGradientId = `gradient-${rightGroup.replace(/\s+/g, '-').toLowerCase()}`; + const rightBaseColor = getColor(rightGroup); + + const rightGradient = defs.append("linearGradient") + .attr("id", rightGradientId) + .attr("x1", "100%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "0%"); + + rightGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(rightBaseColor, { mode: "brighter", amount: 1.2 })); + + rightGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(rightBaseColor, { mode: "darker", amount: 0.7 })); + } + + // ---------- 7. 添加左右组标签 ---------- + + const formattedLeftGroup = groupUnit ? `${leftGroup}${groupUnit}` : `${leftGroup}`; + svg.append("text") + .attr("x", margin.left + innerWidth / 4) + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedLeftGroup); + + const formattedRightGroup = groupUnit ? `${rightGroup}${groupUnit}` : `${rightGroup}`; + svg.append("text") + .attr("x", margin.left + innerWidth * 3 / 4) + .attr("y", margin.top - 10) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedRightGroup); + + // ---------- 8. 创建绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left},${margin.top})`); + + // ---------- 9. 创建比例尺 ---------- + + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(variables.has_spacing ? 0.4 : 0.3); + + const maxLeftValue = d3.max(chartData.filter(d => d[groupField] === leftGroup), d => +d[valueField]); + const maxRightValue = d3.max(chartData.filter(d => d[groupField] === rightGroup), d => +d[valueField]); + + const leftXScale = d3.scaleLinear() + .domain([0, maxLeftValue]) + .range([innerWidth / 2 - dimensionLabelWidth/2, 0]); + + const rightXScale = d3.scaleLinear() + .domain([0, maxRightValue]) + .range([0, innerWidth / 2 - dimensionLabelWidth/2]); + + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // ---------- 9. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", "#f5f5f5") + .attr("opacity", 0.8); + } + }); + } + +// ---------- 10. 绘制维度标签和图标 ---------- + + dimensions.forEach(dimension => { + const yPos = yScale(dimension) + yScale.bandwidth() / 2; + + const flagWidth = 20; + const flagHeight = 15; + const flagPadding = 0; + + const formattedDimension = dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}`; + + const textWidth = chartUtils.text.measure(g, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + + + if (showIcons) { + // If showing icons, calculate total width including the icon + const totalWidth = flagWidth + flagPadding + textWidth; + const startX = innerWidth/2 - totalWidth/2; + + // Add icon if it exists and if we should show icons + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", startX) + .attr("y", yPos - flagHeight/2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // Add text after the icon + g.append("text") + .attr("x", startX + flagWidth + flagPadding) + .attr("y", yPos) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .text(formattedDimension); + } else { + // If not showing icons, center the text only + const startX = innerWidth/2; + + // Add centered text without icon + g.append("text") + .attr("x", startX) + .attr("y", yPos) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .text(formattedDimension); + } + }); + + // ---------- 11. 绘制左侧条形图 ---------- + + dimensions.forEach(dimension => { + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === leftGroup + ); + + if (dataPoint) { + const barWidth = innerWidth/2 - dimensionLabelWidth/2 - leftXScale(+dataPoint[valueField]); + const yPos = yScale(dimension); + + // ★ 改动处：让"右边缘"竖直，"左边缘"倾斜，下边比上边略宽 + const slopeLeft = 5; // 下边较上边多出的宽度 + const xStart = leftXScale(+dataPoint[valueField]); + const barHeight = yScale.bandwidth(); + + // 顶部：从 xStart 到 xStart + barWidth（右侧垂直线起点） + // 底部：右侧同样 xStart + barWidth，左侧 xStart - slopeLeft + const pathDataLeft = [ + `M ${xStart} ${yPos}`, // 左上 + `L ${xStart + barWidth} ${yPos}`, // 右上(竖直边的上端) + `L ${xStart + barWidth} ${yPos + barHeight}`, // 右下(竖直边的下端) + `L ${xStart - slopeLeft} ${yPos + barHeight}`, // 左下(向左偏移 slope) + "Z" + ].join(" "); + + g.append("path") + .attr("d", pathDataLeft) + .attr("fill", variables.has_gradient ? + `url(#gradient-${leftGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(leftGroup) + ) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 0.8); + }) + .on("mouseout", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 1); + }); + + // ------- 以下是数值标签原逻辑，不作改动 ------- + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + let textX = leftXScale(+dataPoint[valueField]) + barWidth/2; + const rightBoundary = leftXScale(+dataPoint[valueField]) + barWidth; + if (textX + textWidth/2 > rightBoundary) { + textX = rightBoundary - textWidth/2 - 2; + } + g.append("text") + .attr("class", "label") + .attr("x", leftXScale(+dataPoint[valueField]) - slopeLeft*1.5) // More generous padding + .attr("y", yPos + yScale.bandwidth()/2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + + // if (barWidth < textWidth) { + // g.append("text") + // .attr("class", "label") + // .attr("x", leftXScale(+dataPoint[valueField]) - slopeLeft) // More generous padding + // .attr("y", yPos + yScale.bandwidth()/2) + // .attr("dy", "0.35em") + // .attr("text-anchor", "end") + // .style("fill", colorResolver.text({ fallback: "#333333" }).value) + // .style("font-family", typography.annotation.font_family) + // .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + // .style("font-weight", typography.annotation.font_weight) + // .style("pointer-events", "none") + // .text(formattedValue); + // } else { + // g.append("text") + // .attr("class", "label") + // .attr("x", textX) + // .attr("y", yPos + yScale.bandwidth()/2) + // .attr("dy", "0.35em") + // .attr("text-anchor", "middle") + // .style("fill", "#ffffff") + // .style("font-family", typography.annotation.font_family) + // .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + // .style("font-weight", typography.annotation.font_weight) + // .style("pointer-events", "none") + // .text(formattedValue); + // } + } + }); + + // ---------- 12. 绘制右侧条形图 ---------- + + dimensions.forEach(dimension => { + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === rightGroup + ); + + if (dataPoint) { + const barWidth = rightXScale(+dataPoint[valueField]); + const yPos = yScale(dimension); + const barLeft = innerWidth/2 + dimensionLabelWidth/2; + + // ★ 改动处：让"左边缘"竖直，"右边缘"倾斜，下边比上边略宽 + const slopeRight = 5; // 下边比上边多出的宽度 + const barHeight = yScale.bandwidth(); + + // 顶部：从 barLeft 到 barLeft + barWidth（左侧竖直线为barLeft） + // 底部：左侧同样 barLeft，右侧为 barLeft + barWidth + slopeRight + const pathDataRight = [ + `M ${barLeft} ${yPos}`, // 左上(竖直边的上端) + `L ${barLeft + barWidth} ${yPos}`, // 右上 + `L ${barLeft + barWidth + slopeRight} ${yPos + barHeight}`, // 右下(向右偏移 slope) + `L ${barLeft} ${yPos + barHeight}`, // 左下(竖直边的下端) + "Z" + ].join(" "); + + g.append("path") + .attr("d", pathDataRight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${rightGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(rightGroup) + ) + .attr("rx", variables.has_rounded_corners ? 4 : 0) + .attr("ry", variables.has_rounded_corners ? 4 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 0.8); + }) + .on("mouseout", function(event, d) { + d3.select(this) + .transition() + .duration(100) + .attr("opacity", 1); + }); + + // ------- 以下是数值标签原逻辑，不作改动 ------- + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + let textX = barLeft + barWidth/2; + if (textX - textWidth/2 < barLeft) { + textX = barLeft + textWidth/2 + 2; + } + g.append("text") + .attr("class", "label") + .attr("x", barLeft + barWidth + slopeRight*2) + .attr("y", yPos + yScale.bandwidth()/2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + // if (barWidth < textWidth) { + // g.append("text") + // .attr("class", "label") + // .attr("x", barLeft + barWidth + slopeRight*1.4) + // .attr("y", yPos + yScale.bandwidth()/2) + // .attr("dy", "0.35em") + // .attr("text-anchor", "start") + // .style("fill", colorResolver.text({ fallback: "#333333" }).value) + // .style("font-family", typography.annotation.font_family) + // .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + // .style("font-weight", typography.annotation.font_weight) + // .style("pointer-events", "none") + // .text(formattedValue); + // } else { + // g.append("text") + // .attr("class", "label") + // .attr("x", textX) + // .attr("y", yPos + yScale.bandwidth()/2) + // .attr("dy", "0.35em") + // .attr("text-anchor", "middle") + // .style("fill", "#ffffff") + // .style("font-family", typography.annotation.font_family) + // .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + // .style("font-weight", typography.annotation.font_weight) + // .style("pointer-events", "none") + // .text(formattedValue); + // } + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..f5db02c0dbbda6ea94d089b498ceef07ef5e63ed --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_04_hand.js @@ -0,0 +1,584 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_04_hand", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const rowsRaw = (jsonData.data && jsonData.data.data) || []; + const typography = jsonData.typography || {}; + const images = jsonData.images || { field: {}, other: {} }; + const fieldImages = images.field || {}; + const primaryImage = images.other && images.other.primary; + const colorResolver = chartUtils.color.resolver(jsonData); + const columns = chartUtils.schema.columns(jsonData); + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + const valueUnit = valueChannel.unit && valueChannel.unit !== "none" ? valueChannel.unit : ""; + const dimensionColumn = columns.find(c => c.name === dimensionField) || {}; + + d3.select(containerSelector).html(""); + + const width = 1024; + const height = 1536; + const titleText = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || + "Diverging Comparison"; + const subtitleText = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || + jsonData.description || + ""; + + function safeId(value) { + return String(value || "") + .replace(/[^a-zA-Z0-9_-]+/g, "-") + .replace(/^-+|-+$/g, "") + .toLowerCase() || "item"; + } + + function humanize(value) { + return String(value == null ? "" : value) + .replace(/_/g, " ") + .replace(/\s+/g, " ") + .trim(); + } + + const isTemporal = dimensionColumn.data_type === "temporal" || + rowsRaw.every(d => /^\d{4}$/.test(String(d[dimensionField]))); + function parseTemporal(value) { + const raw = String(value); + if (/^\d{4}$/.test(raw)) return +raw; + const parsed = Date.parse(raw); + return Number.isFinite(parsed) ? parsed : raw; + } + + const groups = [...new Set(rowsRaw.map(d => d[groupField]).filter(v => v !== undefined))].slice(0, 2); + const leftGroup = groups[0] || "Left"; + const rightGroup = groups[1] || "Right"; + let dimensions = [...new Set(rowsRaw.map(d => d[dimensionField]).filter(v => v !== undefined))]; + if (isTemporal) { + dimensions = dimensions.sort((a, b) => { + const av = parseTemporal(a); + const bv = parseTemporal(b); + if (typeof av === "number" && typeof bv === "number") return av - bv; + return String(a).localeCompare(String(b)); + }); + } + + const lookup = new Map(); + rowsRaw.forEach((d, i) => { + lookup.set(`${d[dimensionField]}|||${d[groupField]}`, { + ...d, + __inputIndex: i, + __value: +d[valueField] || 0 + }); + }); + const rowData = dimensions.map((dimension, index) => ({ + dimension, + index, + left: lookup.get(`${dimension}|||${leftGroup}`), + right: lookup.get(`${dimension}|||${rightGroup}`) + })).filter(row => row.left || row.right); + const rowCount = Math.max(1, rowData.length); + + function groupColor(group, fallback, side) { + const resolved = colorResolver.field(group, 0, { + fallbackKey: side === "left" ? "primary" : "secondary" + }).value; + return resolved || fallback; + } + const leftColor = groupColor(leftGroup, "#2565D9", "left"); + const rightColor = groupColor(rightGroup, "#FF6B1A", "right"); + const titleColor = "#070B28"; + const mutedText = "#3E4652"; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("style", "max-width: 100%; height: auto;"); + + const defs = svg.append("defs"); + const bg = defs.append("linearGradient") + .attr("id", "hdbc04hand-bg") + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "100%").attr("y2", "100%"); + bg.append("stop").attr("offset", "0%").attr("stop-color", "#F7F6FF"); + bg.append("stop").attr("offset", "55%").attr("stop-color", "#F2F5FF"); + bg.append("stop").attr("offset", "100%").attr("stop-color", "#EFF5FF"); + + function addGradient(id, base, side) { + const gradient = defs.append("linearGradient") + .attr("id", id) + .attr("x1", side === "left" ? "100%" : "0%") + .attr("x2", side === "left" ? "0%" : "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(base, { mode: "darker", amount: 0.08 })); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(base, { mode: "brighter", amount: 0.18 })); + } + addGradient("hdbc04hand-left-bar", leftColor, "left"); + addGradient("hdbc04hand-right-bar", rightColor, "right"); + + const shadow = defs.append("filter") + .attr("id", "hdbc04hand-soft-shadow") + .attr("x", "-20%").attr("y", "-20%") + .attr("width", "140%").attr("height", "140%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 9) + .attr("flood-color", "#51607A") + .attr("flood-opacity", 0.16); + + svg.append("rect") + .attr("x", 0).attr("y", 0) + .attr("width", width).attr("height", height) + .attr("fill", "url(#hdbc04hand-bg)"); + + function measure(text, fontSize, fontWeight = 400, family = "Arial, Helvetica, sans-serif") { + return chartUtils.text.measure(svg, String(text || ""), { + fontFamily: family, + fontSize: `${fontSize}px`, + fontWeight + }).width; + } + + function wrapLines(text, maxWidth, fontSize, fontWeight, maxLines, family = "Arial, Helvetica, sans-serif") { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const candidate = current ? `${current} ${word}` : word; + if (current && measure(candidate, fontSize, fontWeight, family) > maxWidth) { + lines.push(current); + current = word; + } else { + current = candidate; + } + }); + if (current) lines.push(current); + const visible = lines.slice(0, maxLines); + if (lines.length > maxLines && visible.length) { + let last = visible[visible.length - 1]; + while (last.length > 4 && measure(`${last}...`, fontSize, fontWeight, family) > maxWidth) { + const next = last.split(/\s+/).slice(0, -1).join(" "); + if (!next) break; + last = next; + } + visible[visible.length - 1] = `${last}...`; + } + return visible.length ? visible : [""]; + } + + function addWrappedText(parent, text, x, y, maxWidth, options) { + const cfg = { + fontFamily: "Arial, Helvetica, sans-serif", + fontSize: 24, + fontWeight: 400, + fill: mutedText, + anchor: "start", + lineHeight: 1.22, + maxLines: 3, + ...options + }; + const lines = wrapLines(text, maxWidth, cfg.fontSize, cfg.fontWeight, cfg.maxLines, cfg.fontFamily); + const el = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", cfg.anchor) + .style("font-family", cfg.fontFamily) + .style("font-size", `${cfg.fontSize}px`) + .style("font-weight", cfg.fontWeight) + .style("fill", cfg.fill) + .style("letter-spacing", "0"); + lines.forEach((line, i) => { + el.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : `${cfg.lineHeight}em`) + .text(line); + }); + return { element: el, lines }; + } + + function formatValue(value) { + const abs = Math.abs(value); + let text; + if (abs >= 1000) { + const scaled = value / 1000; + text = `${Number.isInteger(scaled) ? scaled.toFixed(0) : scaled.toFixed(1).replace(/0$/, "").replace(/\.$/, "")}K`; + } else if (abs >= 10) { + text = Number.isInteger(value) ? String(value) : value.toFixed(1).replace(/0$/, "").replace(/\.$/, ""); + } else { + text = chartUtils.format.autoText(value); + } + return `${text}${valueUnit && !text.endsWith(valueUnit) ? valueUnit : ""}`; + } + + const hasHeaderAssetCandidate = !!primaryImage; + function hasCategoryAssetCandidate(dimension) { + return !!fieldImages[dimension]; + } + + const headerArt = { x: 58, y: 64, w: 310, h: 370 }; + const titleBox = { x: 384, y: 116, w: 600, h: 230 }; + const artSlot = svg.append("g") + .attr("class", "asset-slot header-thematic-art-slot") + .attr("data-asset-slot", "header-thematic-art") + .attr("data-reserved-slot", "header_thematic_art") + .attr("data-asset-source-policy", hasHeaderAssetCandidate ? "input_asset_or_image2_asset_downstream_only" : "image2_asset_or_neutral_placeholder") + .attr("data-anchor", "upper-left-header-safe-area") + .attr("data-collision-rule", "stay left of title/subtitle and above chart panel; do not overlap title, subtitle, legend, or bars") + .attr("data-bbox", `${headerArt.x},${headerArt.y},${headerArt.w},${headerArt.h}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + artSlot.append("rect") + .attr("x", headerArt.x + 32) + .attr("y", headerArt.y + 48) + .attr("width", headerArt.w - 64) + .attr("height", headerArt.h - 96) + .attr("rx", 20) + .attr("fill", "#F6FAFF") + .attr("stroke", "#BCD0EC") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "9 9") + .attr("opacity", 0.82); + artSlot.append("circle") + .attr("cx", headerArt.x + headerArt.w / 2) + .attr("cy", headerArt.y + headerArt.h / 2) + .attr("r", 34) + .attr("fill", "none") + .attr("stroke", "#D1DDF0") + .attr("stroke-width", 2) + .attr("opacity", 0.9); + + const titleFamily = (typography.title && typography.title.font_family) || "Arial, Helvetica, sans-serif"; + const titleFontSize = 44; + const titleLines = wrapLines(titleText, titleBox.w, titleFontSize, 900, 2, titleFamily); + const titleEl = svg.append("text") + .attr("class", "title") + .attr("x", titleBox.x) + .attr("y", titleBox.y) + .attr("text-anchor", "start") + .style("font-family", titleFamily) + .style("font-size", `${titleFontSize}px`) + .style("font-weight", 900) + .style("fill", titleColor) + .style("letter-spacing", "0"); + titleLines.forEach((line, i) => { + titleEl.append("tspan") + .attr("x", titleBox.x) + .attr("dy", i === 0 ? 0 : "1.1em") + .text(line); + }); + const ruleY = titleBox.y + Math.min(158, titleLines.length * (titleFontSize * 1.1) + 16); + svg.append("line") + .attr("x1", titleBox.x + 4) + .attr("x2", titleBox.x + 374) + .attr("y1", ruleY) + .attr("y2", ruleY) + .attr("stroke", leftColor) + .attr("stroke-width", 4) + .attr("stroke-linecap", "round"); + svg.append("line") + .attr("x1", titleBox.x + 316) + .attr("x2", titleBox.x + 436) + .attr("y1", ruleY) + .attr("y2", ruleY) + .attr("stroke", rightColor) + .attr("stroke-width", 4) + .attr("stroke-linecap", "round"); + addWrappedText(svg, subtitleText, titleBox.x + 4, ruleY + 36, titleBox.w - 28, { + fontFamily: "Arial, Helvetica, sans-serif", + fontSize: 25, + fontWeight: 400, + fill: mutedText, + maxLines: 3, + lineHeight: 1.3 + }); + + const legendY = ruleY + 140; + function addLegendItem(x, group, color) { + svg.append("circle") + .attr("cx", x) + .attr("cy", legendY) + .attr("r", 13) + .attr("fill", color); + svg.append("text") + .attr("x", x + 28) + .attr("y", legendY + 7) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", "22px") + .style("font-weight", 500) + .style("fill", "#151B26") + .text(humanize(group)); + } + addLegendItem(titleBox.x + 8, leftGroup, leftColor); + addLegendItem(titleBox.x + 258, rightGroup, rightColor); + svg.append("line") + .attr("x1", titleBox.x + 226) + .attr("x2", titleBox.x + 226) + .attr("y1", legendY - 20) + .attr("y2", legendY + 24) + .attr("stroke", "#C6CCD7") + .attr("stroke-width", 1.5); + + const panel = { x: 42, y: 455, w: 940, h: 965 }; + svg.append("rect") + .attr("class", "chart-panel") + .attr("x", panel.x) + .attr("y", panel.y) + .attr("width", panel.w) + .attr("height", panel.h) + .attr("rx", 28) + .attr("fill", "#FFFFFF") + .attr("filter", "url(#hdbc04hand-soft-shadow)") + .attr("opacity", 0.98); + + const inner = { + x: panel.x + 48, + y: panel.y + 92, + w: panel.w - 96, + h: panel.h - 155 + }; + const leftInnerX = panel.x + 390; + const rightInnerX = panel.x + 560; + const leftOuterMin = panel.x + 128; + const rightOuterMax = panel.x + panel.w - 132; + const iconX = panel.x + panel.w / 2; + const rowBand = inner.h / rowCount; + const rowGap = Math.max(6, Math.min(14, rowBand * 0.14)); + const barH = Math.max(23, Math.min(58, rowBand - rowGap)); + const chipR = Math.max(17, Math.min(29, barH * 0.50)); + const leftMax = d3.max(rowsRaw.filter(d => d[groupField] === leftGroup), d => +d[valueField] || 0) || 1; + const rightMax = d3.max(rowsRaw.filter(d => d[groupField] === rightGroup), d => +d[valueField] || 0) || 1; + const leftScale = d3.scaleLinear().domain([0, leftMax]).range([0, leftInnerX - leftOuterMin]); + const rightScale = d3.scaleLinear().domain([0, rightMax]).range([0, rightOuterMax - rightInnerX]); + + function addHeaderPill(group, x, y, color) { + const label = String(group || "").toUpperCase(); + const pillW = Math.min(260, Math.max(150, measure(label, 24, 900) + 54)); + const pill = svg.append("g") + .attr("class", "group-header") + .attr("data-group", String(group)) + .attr("data-anchor", "bar-subcolumn-center") + .attr("data-coordinate-rule", "centerline-aligned-to-side-bar-column"); + pill.append("rect") + .attr("x", x - pillW / 2) + .attr("y", y - 33) + .attr("width", pillW) + .attr("height", 52) + .attr("rx", 14) + .attr("fill", color); + pill.append("text") + .attr("x", x) + .attr("y", y + 2) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", label.length > 15 ? "18px" : "24px") + .style("font-weight", 900) + .style("fill", "#FFFFFF") + .text(label); + } + addHeaderPill(leftGroup, panel.x + 260, panel.y + 58, leftColor); + addHeaderPill(rightGroup, panel.x + 704, panel.y + 58, rightColor); + + rowData.forEach((row, index) => { + const y0 = inner.y + index * rowBand; + if (index > 0) { + svg.append("line") + .attr("class", "row-separator") + .attr("x1", panel.x + 24) + .attr("x2", panel.x + panel.w - 24) + .attr("y1", y0) + .attr("y2", y0) + .attr("stroke", "#E5EAF2") + .attr("stroke-width", 1.2) + .attr("stroke-dasharray", "5 5") + .attr("opacity", 0.86); + } + }); + + function roundedBarPath(xInner, y, barWidth, h, side) { + const r = Math.min(6, h * 0.12, Math.max(2, barWidth / 2)); + if (side === "left") { + const xOuter = xInner - barWidth; + return [ + `M ${xInner} ${y + r}`, + `Q ${xInner} ${y} ${xInner - r} ${y}`, + `L ${xOuter + r} ${y}`, + `Q ${xOuter} ${y} ${xOuter} ${y + r}`, + `L ${xOuter} ${y + h - r}`, + `Q ${xOuter} ${y + h} ${xOuter + r} ${y + h}`, + `L ${xInner - r} ${y + h}`, + `Q ${xInner} ${y + h} ${xInner} ${y + h - r}`, + "Z" + ].join(" "); + } + const xOuter = xInner + barWidth; + return [ + `M ${xInner} ${y + r}`, + `Q ${xInner} ${y} ${xInner + r} ${y}`, + `L ${xOuter - r} ${y}`, + `Q ${xOuter} ${y} ${xOuter} ${y + r}`, + `L ${xOuter} ${y + h - r}`, + `Q ${xOuter} ${y + h} ${xOuter - r} ${y + h}`, + `L ${xInner + r} ${y + h}`, + `Q ${xInner} ${y + h} ${xInner} ${y + h - r}`, + "Z" + ].join(" "); + } + + function addValueLabel(value, x, cy, side, barWidth) { + const text = formatValue(value); + const fontSize = Math.max(24, Math.min(34, barH * 0.66)); + const textW = measure(text, fontSize, 900); + let labelX; + let anchor; + if (side === "left") { + labelX = Math.max(panel.x + 60 + textW, x - 18); + anchor = "end"; + if (labelX > x - 12) labelX = x - 12; + } else { + labelX = Math.min(panel.x + panel.w - 38 - textW, x + 18); + anchor = "start"; + } + svg.append("text") + .attr("class", `value-label ${side}-value-label`) + .attr("x", labelX) + .attr("y", cy) + .attr("dy", "0.35em") + .attr("text-anchor", anchor) + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", `${fontSize}px`) + .style("font-weight", 900) + .style("fill", side === "left" ? leftColor : rightColor) + .style("letter-spacing", "0") + .text(text); + } + + function addCategorySlot(row, cy) { + const dimension = row.dimension; + const slot = svg.append("g") + .attr("class", "asset-slot category-icon-slot") + .attr("data-asset-slot", "category-icon") + .attr("data-category", String(dimension)) + .attr("data-asset-source-policy", hasCategoryAssetCandidate(dimension) ? "input_asset_or_retrieval_downstream_only" : "neutral_placeholder") + .attr("data-anchor", "row-centerline-central-label-column") + .attr("data-collision-rule", "stay inside central label column; avoid flat bar inner edges and value labels") + .attr("data-bbox", `${(iconX - chipR).toFixed(1)},${(cy - chipR).toFixed(1)},${(chipR * 2).toFixed(1)},${(chipR * 2).toFixed(1)}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle") + .attr("cx", iconX) + .attr("cy", cy) + .attr("r", chipR) + .attr("fill", "#FFFFFF") + .attr("stroke", "#E3E9F2") + .attr("stroke-width", 1.4) + .attr("filter", "url(#hdbc04hand-soft-shadow)"); + slot.append("circle") + .attr("cx", iconX) + .attr("cy", cy) + .attr("r", Math.max(4, chipR * 0.18)) + .attr("fill", "#DDE7F5") + .attr("opacity", 0.95); + } + + rowData.forEach(row => { + const cy = inner.y + row.index * rowBand + rowBand / 2; + const y = cy - barH / 2; + const leftValue = row.left ? +row.left[valueField] || 0 : 0; + const rightValue = row.right ? +row.right[valueField] || 0 : 0; + const leftW = leftValue > 0 ? Math.max(4, leftScale(leftValue)) : 0; + const rightW = rightValue > 0 ? Math.max(4, rightScale(rightValue)) : 0; + if (leftW > 0) { + svg.append("path") + .attr("class", "bar left-bar") + .attr("d", roundedBarPath(leftInnerX, y, leftW, barH, "left")) + .attr("fill", "url(#hdbc04hand-left-bar)") + .attr("data-category", String(row.dimension)) + .attr("data-group", String(leftGroup)) + .attr("data-value", leftValue) + .attr("data-cap-geometry", "small-radius-rounded-inner-and-outer-edges"); + } + if (rightW > 0) { + svg.append("path") + .attr("class", "bar right-bar") + .attr("d", roundedBarPath(rightInnerX, y, rightW, barH, "right")) + .attr("fill", "url(#hdbc04hand-right-bar)") + .attr("data-category", String(row.dimension)) + .attr("data-group", String(rightGroup)) + .attr("data-value", rightValue) + .attr("data-cap-geometry", "small-radius-rounded-inner-and-outer-edges"); + } + addValueLabel(leftValue, leftInnerX - leftW, cy, "left", leftW); + addValueLabel(rightValue, rightInnerX + rightW, cy, "right", rightW); + addCategorySlot(row, cy); + const labelText = humanize(row.dimension); + const labelMaxWidth = Math.max(112, rightInnerX - leftInnerX - chipR * 2 - 10); + let fontSize = Math.max(13, Math.min(18, rowBand * 0.20)); + let labelLines = wrapLines(labelText, labelMaxWidth, fontSize, 700, 2, "Arial, Helvetica, sans-serif"); + if (labelLines.length > 1) { + fontSize = Math.max(12, fontSize - 2); + labelLines = wrapLines(labelText, labelMaxWidth, fontSize, 700, 2, "Arial, Helvetica, sans-serif"); + } + const firstLineY = cy + chipR + (labelLines.length > 1 ? 8 : 16); + const label = svg.append("text") + .attr("class", "category-label") + .attr("x", iconX) + .attr("y", firstLineY) + .attr("text-anchor", "middle") + .style("font-family", "Arial, Helvetica, sans-serif") + .style("font-size", `${fontSize}px`) + .style("font-weight", 700) + .style("fill", "#141A24") + .style("letter-spacing", "0"); + labelLines.forEach((line, i) => { + label.append("tspan") + .attr("x", iconX) + .attr("dy", i === 0 ? 0 : "1.02em") + .text(line); + }); + }); + + svg.append("g") + .attr("class", "ignored-bottom-wrapper-policy") + .attr("data-ignored-element", "bottom_takeaway_source_footer") + .attr("data-policy", "not-rendered"); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_05.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_05.js new file mode 100644 index 0000000000000000000000000000000000000000..a9d28f36e91979c9fade5d8bf55da3c6fde459b4 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_05.js @@ -0,0 +1,767 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_05", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Georgia", font_size: "32px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "14px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "15px", font_weight: 400 }, + annotation: { font_family: "Arial", font_size: "13px", font_weight: 500 } + }; + const colorResolver = chartUtils.color.resolver(jsonData); + const width = Math.max(720, +variables.width || 1024); + const height = Math.max(920, +variables.height || 1536); + + d3.select(containerSelector).html(""); + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + const bgGradient = defs.append("radialGradient") + .attr("id", "hdbar05-bg") + .attr("cx", "50%") + .attr("cy", "18%") + .attr("r", "85%"); + bgGradient.append("stop").attr("offset", "0%").attr("stop-color", "#FFFDF6"); + bgGradient.append("stop").attr("offset", "72%").attr("stop-color", "#F7F0E3"); + bgGradient.append("stop").attr("offset", "100%").attr("stop-color", "#EFE2CD"); + + const shadow = defs.append("filter") + .attr("id", "hdbar05-soft-shadow") + .attr("x", "-20%") + .attr("y", "-35%") + .attr("width", "150%") + .attr("height", "190%"); + shadow.append("feDropShadow") + .attr("dx", "0") + .attr("dy", "7") + .attr("stdDeviation", "5") + .attr("flood-color", "#1E2A31") + .attr("flood-opacity", "0.20"); + + const leftBase = "#0F6B3B"; + const rightBase = "#1F63B7"; + const leftColor = d3.color(leftBase) ? d3.color(leftBase).formatHex() : "#0F6B3B"; + const rightColor = d3.color(rightBase) ? d3.color(rightBase).formatHex() : "#1C5FB5"; + + function gradient(id, color, darkenAmount) { + const base = d3.color(color); + const hi = base ? base.brighter(0.65).formatHex() : color; + const lo = base ? base.darker(darkenAmount).formatHex() : color; + const g = defs.append("linearGradient").attr("id", id).attr("x1", "0%").attr("x2", "100%").attr("y1", "0%").attr("y2", "0%"); + g.append("stop").attr("offset", "0%").attr("stop-color", hi); + g.append("stop").attr("offset", "58%").attr("stop-color", color); + g.append("stop").attr("offset", "100%").attr("stop-color", lo); + } + gradient("hdbar05-left-gradient", leftColor, 0.9); + gradient("hdbar05-right-gradient", rightColor, 0.75); + + svg.append("rect").attr("width", width).attr("height", height).attr("fill", "url(#hdbar05-bg)"); + + const schemaX = chartUtils.schema.channel(jsonData, "x"); + const schemaY = chartUtils.schema.channel(jsonData, "y"); + const schemaGroup = chartUtils.schema.channel(jsonData, "group"); + const dimensionField = schemaX.key; + const valueField = schemaY.key; + const groupField = schemaGroup.key; + const valueUnit = schemaY.unit && schemaY.unit !== "none" ? schemaY.unit : ""; + const groupUnit = schemaGroup.unit && schemaGroup.unit !== "none" ? schemaGroup.unit : ""; + const dimensionUnit = schemaX.unit && schemaX.unit !== "none" ? schemaX.unit : ""; + + function isTemporalField() { + const col = (chartUtils.schema.columns(jsonData) || []).find(c => c.name === dimensionField) || {}; + return /date|time|year|month|season|semester|quarter/i.test(`${dimensionField} ${col.description || ""} ${col.data_type || ""}`); + } + + const monthMap = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, + september: 9, oct: 10, october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + + function temporalKey(value) { + if (value instanceof Date) return value.getTime(); + if (typeof value === "number" && Number.isFinite(value)) return value; + const text = String(value || "").trim(); + const lower = text.toLowerCase(); + if (/^-?\d+(\.\d+)?$/.test(text)) return +text; + if (monthMap[lower]) return monthMap[lower]; + const quarter = lower.match(/q([1-4])\s*[- ]?\s*(\d{2,4})?|\b(\d{2,4})\s*q([1-4])\b/); + if (quarter) { + const q = +(quarter[1] || quarter[4]); + const year = +(quarter[2] || quarter[3] || 0); + return year * 10 + q; + } + const parsed = Date.parse(text); + return Number.isNaN(parsed) ? null : parsed; + } + + const temporalDimension = isTemporalField(); + const rawDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const dimensions = rawDimensions.slice(); + if (temporalDimension) { + dimensions.sort((a, b) => { + const ak = temporalKey(a); + const bk = temporalKey(b); + if (ak == null || bk == null) return rawDimensions.indexOf(a) - rawDimensions.indexOf(b); + return ak - bk; + }); + } + const groups = [...new Set(chartData.map(d => d[groupField]))].slice(0, 2); + const leftGroup = groups[0] || "Left"; + const rightGroup = groups[1] || "Right"; + const leftGroupText = groupUnit ? `${leftGroup}${groupUnit}` : `${leftGroup}`; + const rightGroupText = groupUnit ? `${rightGroup}${groupUnit}` : `${rightGroup}`; + + const byKey = new Map(); + chartData.forEach(d => byKey.set(`${d[dimensionField]}|||${d[groupField]}`, d)); + const maxValue = Math.max(1, d3.max(chartData, d => +d[valueField]) || 1); + const axisMax = maxValue <= 100 ? 100 : Math.ceil(maxValue / 10) * 10; + const ticks = d3.range(0, axisMax + 0.1, axisMax / 5); + + function splitTitle(title) { + const words = String(title || "").trim().split(/\s+/).filter(Boolean); + const stabilityIndex = words.findIndex(w => /^stability/i.test(w)); + const indexIndex = words.findIndex(w => /^index/i.test(w)); + if (stabilityIndex > 0 && indexIndex > stabilityIndex) { + const first = words.slice(0, indexIndex).join(" "); + const overIndex = words.findIndex((w, i) => i > indexIndex && /^over$/i.test(w)); + const secondTail = overIndex > indexIndex + ? "" + : words.slice(stabilityIndex + 1, indexIndex).join(" "); + const second = secondTail; + const banner = words.slice(indexIndex).join(" "); + return { first, second, banner }; + } + return { + first: words.slice(0, Math.max(2, Math.ceil(words.length / 2))).join(" "), + second: words.slice(Math.max(2, Math.ceil(words.length / 2))).join(" "), + banner: words.slice(Math.max(1, Math.floor(words.length / 2))).join(" ") + }; + } + + function fitText(selection, maxWidth, minSize) { + selection.each(function() { + const node = d3.select(this); + let size = parseFloat(node.style("font-size")) || parseFloat(node.attr("font-size")) || 20; + while (this.getComputedTextLength && this.getComputedTextLength() > maxWidth && size > minSize) { + size -= 1; + node.style("font-size", `${size}px`).attr("font-size", size); + } + }); + } + + function estimatedTextWidth(text, fontSize) { + return String(text || "").length * fontSize * 0.58; + } + + function ellipsizeToWidth(text, maxWidth, fontSize) { + const raw = String(text || ""); + if (estimatedTextWidth(raw, fontSize) <= maxWidth) return raw; + const maxChars = Math.max(4, Math.floor(maxWidth / (fontSize * 0.58))); + if (maxChars <= 4) return raw.slice(0, Math.max(1, maxChars - 1)) + "..."; + return raw.slice(0, maxChars - 3).replace(/[.,;: _-]+$/, "") + "..."; + } + + function wrapLines(text, maxChars, maxLines) { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let current = ""; + words.forEach(word => { + const trial = current ? `${current} ${word}` : word; + if (current && trial.length > maxChars && lines.length < maxLines - 1) { + lines.push(current); + current = word; + } else { + current = trial; + } + }); + if (current) lines.push(current); + if (lines.length > maxLines) { + const kept = lines.slice(0, maxLines); + kept[maxLines - 1] = `${kept[maxLines - 1].replace(/[.,;: ]+$/, "")}...`; + return kept; + } + return lines; + } + + const title = (jsonData.titles && jsonData.titles.main_title) || (jsonData.metadata && jsonData.metadata.title) || ""; + const subtitle = (jsonData.titles && jsonData.titles.sub_title) || (jsonData.metadata && jsonData.metadata.description) || ""; + const titleParts = splitTitle(title); + + const gold = "#C59432"; + const darkGreen = "#0E482A"; + const navy = "#132334"; + const chartLeft = width * 0.095; + const chartRight = width * 0.92; + const centerX = width * 0.50; + const rowTop = height * 0.378; + const rowBottom = height * 0.810; + const rowBand = (rowBottom - rowTop) / Math.max(1, dimensions.length); + const barHeight = Math.max(28, Math.min(58, rowBand * 0.62)); + const yearGap = width * 0.108; + const leftAxisStart = width * 0.115; + const labelFontForLayout = Math.max(15, Math.min(29, rowBand * 0.42)); + const maxLeftValueLabelWidth = d3.max(dimensions, dimension => { + const row = byKey.get(`${dimension}|||${leftGroup}`); + if (!row) return 0; + return String(formatValue(Math.max(0, +row[valueField] || 0))).length * labelFontForLayout * 0.70; + }) || 0; + const maxRightValueLabelWidth = d3.max(dimensions, dimension => { + const row = byKey.get(`${dimension}|||${rightGroup}`); + if (!row) return 0; + return String(formatValue(Math.max(0, +row[valueField] || 0))).length * labelFontForLayout * 0.70; + }) || 0; + const centerPillMaxW = temporalDimension + ? Math.max(70, Math.min(92, yearGap * 0.78)) + : Math.max(82, Math.min(112, yearGap * 0.98)); + const nominalLeftAxisEnd = centerX - yearGap * 0.72; + const leftValueLabelSafeRight = centerX - Math.max(36, yearGap * 0.34); + const leftAxisEnd = Math.max( + leftAxisStart + width * 0.21, + Math.min(nominalLeftAxisEnd, leftValueLabelSafeRight - maxLeftValueLabelWidth - 12) + ); + const nominalRightAxisStart = centerX + yearGap * 1.08; + const rightValueLabelSafeLeft = Math.max( + centerX + Math.max(32, yearGap * 0.30), + centerX + centerPillMaxW / 2 + 18 + ); + const rightAxisStart = Math.min( + chartRight - width * 0.22, + Math.max(nominalRightAxisStart, rightValueLabelSafeLeft + maxRightValueLabelWidth + 24) + ); + const rowCardHeight = Math.max(barHeight + 14, Math.min(rowBand * 0.78, 66)); + const rowCardRadius = Math.min(16, rowCardHeight * 0.28); + const rowIconRadius = Math.max(13, Math.min(25, rowCardHeight * 0.40)); + const leftRowCardX = width * 0.038; + const leftRowCardW = Math.max(leftAxisEnd + width * 0.018, leftValueLabelSafeRight + 8) - leftRowCardX; + const rightRowCardX = Math.min(rightAxisStart - width * 0.018, centerX + yearGap * 0.52); + const rightRowCardW = (width * 0.966) - rightRowCardX; + const leftRowIconX = leftRowCardX + rowIconRadius + width * 0.010; + const rightRowIconX = rightRowCardX + rightRowCardW - rowIconRadius - width * 0.010; + const rightSlotClearance = Math.max(18, width * 0.022); + const rightAxisEnd = Math.min(chartRight, rightRowIconX - rowIconRadius - rightSlotClearance); + const leftScale = d3.scaleLinear().domain([0, axisMax]).range([0, leftAxisEnd - leftAxisStart]); + const rightScale = d3.scaleLinear().domain([0, axisMax]).range([0, rightAxisEnd - rightAxisStart]); + const rowCenter = d => rowTop + dimensions.indexOf(d) * rowBand + rowBand / 2; + + function titleOrnament(cx, cy) { + const slot = svg.append("g") + .attr("class", "reserved-asset-slot hdbar05-title-ornament-slot") + .attr("data-asset-slot", "title-ornament") + .attr("data-slot-policy", "image2_asset_or_neutral_placeholder") + .attr("data-asset-source-policy", "image2_asset") + .attr("data-anchor", "top-center-above-title") + .attr("data-collision-rule", "stay outside title/subtitle glyphs and above chart panel") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("line").attr("x1", cx - 18).attr("x2", cx + 18).attr("y1", cy).attr("y2", cy).attr("stroke", gold).attr("stroke-width", 5).attr("stroke-linecap", "round"); + slot.append("line").attr("x1", cx).attr("x2", cx).attr("y1", cy - 18).attr("y2", cy + 18).attr("stroke", gold).attr("stroke-width", 5).attr("stroke-linecap", "round"); + slot.append("circle").attr("cx", cx).attr("cy", cy).attr("r", 5).attr("fill", "#F6E0A0").attr("stroke", gold).attr("stroke-width", 1.2); + } + + titleOrnament(centerX, height * 0.055); + svg.append("line").attr("x1", width * 0.19).attr("x2", width * 0.45).attr("y1", height * 0.075).attr("y2", height * 0.075).attr("stroke", gold).attr("stroke-width", 1.6); + svg.append("line").attr("x1", width * 0.55).attr("x2", width * 0.81).attr("y1", height * 0.075).attr("y2", height * 0.075).attr("stroke", gold).attr("stroke-width", 1.6); + svg.append("circle").attr("cx", width * 0.19).attr("cy", height * 0.075).attr("r", 4).attr("fill", gold); + svg.append("circle").attr("cx", width * 0.81).attr("cy", height * 0.075).attr("r", 4).attr("fill", gold); + + const titleGroup = svg.append("g").attr("class", "hdbar05-title-block"); + const titleFirst = titleGroup.append("text") + .attr("x", centerX) + .attr("y", height * 0.137) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", width * 0.058) + .attr("font-weight", 700) + .attr("letter-spacing", "0") + .attr("fill", darkGreen) + .text((titleParts.first || title).toUpperCase()); + fitText(titleFirst, width * 0.86, 34); + + if (titleParts.second) { + const second = titleGroup.append("text") + .attr("x", centerX) + .attr("y", height * 0.178) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", width * 0.033) + .attr("font-weight", 500) + .attr("letter-spacing", "10") + .attr("fill", navy) + .text(titleParts.second.toUpperCase()); + fitText(second, width * 0.74, 18); + } + + const bannerW = width * 0.84; + const bannerH = height * 0.056; + const bannerY = titleParts.second ? height * 0.205 : height * 0.182; + const notch = bannerH * 0.32; + const bannerX = centerX - bannerW / 2; + const bannerPath = [ + `M${bannerX + notch},${bannerY}`, + `L${bannerX + bannerW - notch},${bannerY}`, + `L${bannerX + bannerW},${bannerY + bannerH / 2}`, + `L${bannerX + bannerW - notch},${bannerY + bannerH}`, + `L${bannerX + notch},${bannerY + bannerH}`, + `L${bannerX},${bannerY + bannerH / 2}`, + "Z" + ].join(" "); + titleGroup.append("path") + .attr("d", bannerPath) + .attr("fill", "#064A2A") + .attr("stroke", "#15351F") + .attr("stroke-width", 3) + .attr("filter", "url(#hdbar05-soft-shadow)"); + titleGroup.append("path") + .attr("d", bannerPath) + .attr("fill", "none") + .attr("stroke", "#F8FAF1") + .attr("stroke-width", 2) + .attr("opacity", 0.92); + const bannerText = titleGroup.append("text") + .attr("x", centerX) + .attr("y", bannerY + bannerH * 0.68) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", bannerH * 0.56) + .attr("font-weight", 800) + .attr("letter-spacing", "1.2") + .attr("fill", "#FFFFFF") + .text((titleParts.banner || title).toUpperCase()); + fitText(bannerText, bannerW * 0.83, Math.max(26, bannerH * 0.38)); + + const subtitleLines = wrapLines(subtitle, 74, 2); + const subtitleFontSize = subtitleLines.length > 1 ? width * 0.019 : width * 0.021; + const subtitleLineGap = subtitleLines.length > 1 ? 27 : 34; + const subtitleStartY = bannerY + bannerH + height * 0.020; + subtitleLines.forEach((line, i) => { + svg.append("text") + .attr("x", centerX) + .attr("y", subtitleStartY + i * subtitleLineGap) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, Helvetica, sans-serif") + .attr("font-size", subtitleFontSize) + .attr("font-weight", 400) + .attr("fill", "#262D34") + .text(line); + }); + + function medallionSlot(cx, cy, color, side) { + const r = width * 0.039; + const slot = svg.append("g") + .attr("class", `reserved-asset-slot hdbar05-group-medallion-slot ${side}`) + .attr("data-asset-slot", `${side}-group-medallion`) + .attr("data-slot-policy", "image2_asset_or_input_asset_or_neutral_placeholder") + .attr("data-asset-source-policy", "image2_asset_or_input_asset") + .attr("data-anchor", `${side}-group-header`) + .attr("data-collision-rule", "stay adjacent to group header and outside bar/value/year-label rows") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bbox", `${(cx - r).toFixed(1)},${(cy - r).toFixed(1)},${(r * 2).toFixed(1)},${(r * 2).toFixed(1)}`); + slot.append("circle") + .attr("cx", cx) + .attr("cy", cy) + .attr("r", r) + .attr("fill", color) + .attr("stroke", "#E6C46C") + .attr("stroke-width", 3); + slot.append("circle") + .attr("cx", cx) + .attr("cy", cy) + .attr("r", r * 0.76) + .attr("fill", "none") + .attr("stroke", "#F5E4A2") + .attr("stroke-width", 2) + .attr("opacity", 0.80); + slot.append("circle") + .attr("cx", cx) + .attr("cy", cy) + .attr("r", r * 0.18) + .attr("fill", "none") + .attr("stroke", "#F5E4A2") + .attr("stroke-width", 2) + .attr("opacity", 0.78); + } + + const headerY = height * 0.325; + const headerPillH = Math.max(44, Math.min(58, rowBand * 0.78)); + const leftMedallionX = width * 0.132; + const rightMedallionX = width * 0.585; + const leftPillX = leftMedallionX + width * 0.020; + const rightPillX = rightMedallionX + width * 0.020; + const leftPillW = width * 0.305; + const rightPillW = width * 0.330; + svg.append("rect") + .attr("class", "hdbar05-group-label-pill left") + .attr("x", leftPillX) + .attr("y", headerY - headerPillH / 2) + .attr("width", leftPillW) + .attr("height", headerPillH) + .attr("rx", 7) + .attr("fill", "#F2F4EA") + .attr("stroke", leftColor) + .attr("stroke-width", 1.2) + .attr("opacity", 0.92); + svg.append("rect") + .attr("class", "hdbar05-group-label-pill right") + .attr("x", rightPillX) + .attr("y", headerY - headerPillH / 2) + .attr("width", rightPillW) + .attr("height", headerPillH) + .attr("rx", 7) + .attr("fill", "#F1F4F8") + .attr("stroke", rightColor) + .attr("stroke-width", 1.2) + .attr("opacity", 0.92); + medallionSlot(leftMedallionX, headerY, leftColor, "left"); + medallionSlot(rightMedallionX, headerY, rightColor, "right"); + const leftHeader = svg.append("text") + .attr("x", leftPillX + width * 0.050) + .attr("y", headerY + 10) + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", width * 0.031) + .attr("font-weight", 700) + .attr("fill", darkGreen) + .text(leftGroupText); + fitText(leftHeader, leftPillW - width * 0.070, 18); + const rightHeader = svg.append("text") + .attr("x", rightPillX + width * 0.050) + .attr("y", headerY + 10) + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", width * 0.031) + .attr("font-weight", 700) + .attr("fill", rightColor) + .text(rightGroupText); + fitText(rightHeader, rightPillW - width * 0.070, 18); + + function measureHeader(value) { + const words = String(value || "") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/[_-]+/g, " ") + .trim() + .split(/\s+/) + .filter(Boolean); + if (!words.length) return "VALUE"; + return words.join(" ").toUpperCase(); + } + + const columnHeaderY = rowTop - rowBand * 0.42; + const leftMeasureHeader = svg.append("text") + .attr("class", "hdbar05-column-measure-header left") + .attr("x", (leftAxisStart + leftAxisEnd) / 2) + .attr("y", columnHeaderY) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", Math.max(14, Math.min(18, rowBand * 0.25))) + .attr("font-weight", 800) + .attr("letter-spacing", "0.6") + .attr("fill", darkGreen) + .text(measureHeader(valueField)); + fitText(leftMeasureHeader, leftAxisEnd - leftAxisStart, 11); + + const rightMeasureHeader = svg.append("text") + .attr("class", "hdbar05-column-measure-header right") + .attr("x", (rightAxisStart + rightAxisEnd) / 2) + .attr("y", columnHeaderY) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", Math.max(14, Math.min(18, rowBand * 0.25))) + .attr("font-weight", 800) + .attr("letter-spacing", "0.6") + .attr("fill", rightColor) + .text(measureHeader(valueField)); + fitText(rightMeasureHeader, rightAxisEnd - rightAxisStart, 11); + + svg.append("text") + .attr("class", "hdbar05-center-header") + .attr("x", centerX) + .attr("y", columnHeaderY) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", Math.max(14, Math.min(19, rowBand * 0.27))) + .attr("font-weight", 800) + .attr("letter-spacing", "0.3") + .attr("fill", "#1B2C22") + .text(temporalDimension ? "YEAR" : compactHeader(dimensionField)); + + svg.append("line") + .attr("x1", centerX) + .attr("x2", centerX) + .attr("y1", rowTop - rowBand * 0.16) + .attr("y2", rowBottom + rowBand * 0.16) + .attr("stroke", darkGreen) + .attr("stroke-width", 3) + .attr("opacity", 0.72) + .attr("stroke-linecap", "round"); + + function barPath(x, y, w, h) { + const c = Math.max(0, Math.min(8, h * 0.18, w * 0.18)); + return [ + `M${x},${y}`, + `L${x + w - c},${y}`, + `L${x + w},${y + c}`, + `L${x + w},${y + h - c}`, + `L${x + w - c},${y + h}`, + `L${x},${y + h}`, + "Z" + ].join(" "); + } + + function formatValue(v) { + return valueUnit ? `${chartUtils.format.autoText(+v)}${valueUnit}` : `${chartUtils.format.autoText(+v)}`; + } + + function valueLabelPlacement(text, barWidth, fontSize, inset) { + const estimatedTextWidth = String(text || "").length * fontSize * 0.62; + return barWidth >= estimatedTextWidth + inset + 8; + } + + function slotId(value) { + return String(value || "row") + .toLowerCase() + .replace(/[^a-z0-9]+/g, "-") + .replace(/^-+|-+$/g, "") + .slice(0, 48) || "row"; + } + + function compactHeader(value) { + const words = String(value || "") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/[_-]+/g, " ") + .trim() + .split(/\s+/) + .filter(Boolean); + if (!words.length) return "LABEL"; + const picked = words.length > 1 ? words[words.length - 1] : words[0]; + return picked.slice(0, 10).toUpperCase(); + } + + const rowLayer = svg.append("g").attr("class", "hdbar05-row-card-layer"); + + function rowCardAndIcon(side, dimension, formattedDimension, cy, color) { + const x = side === "left" ? leftRowCardX : rightRowCardX; + const w = side === "left" ? leftRowCardW : rightRowCardW; + const iconCx = side === "left" ? leftRowIconX : rightRowIconX; + const cardY = cy - rowCardHeight / 2; + const safeDimension = slotId(formattedDimension); + const slot = rowLayer.append("g") + .attr("class", `hdbar05-row-card-with-icon ${side}`) + .attr("data-dimension", formattedDimension) + .attr("data-anchor", `row-${safeDimension}-${side}-container`) + .attr("data-relationship", "row-card-span-matched-to-bar-row-centerline"); + + slot.append("rect") + .attr("class", `row-card ${side}`) + .attr("x", x) + .attr("y", cardY) + .attr("width", w) + .attr("height", rowCardHeight) + .attr("rx", rowCardRadius) + .attr("fill", side === "left" ? "#F1F2E8" : "#EEF2F6") + .attr("stroke", side === "left" ? "#DDE6D5" : "#DCE5F0") + .attr("stroke-width", 1) + .attr("opacity", 0.88); + + const icon = slot.append("g") + .attr("class", `reserved-asset-slot hdbar05-row-icon-slot ${side}`) + .attr("data-asset-slot", `${side}-row-icon-${safeDimension}`) + .attr("data-slot-policy", "input_asset_or_image2_asset_or_neutral_placeholder") + .attr("data-asset-source-policy", "input_asset_or_image2_asset") + .attr("data-dimension", formattedDimension) + .attr("data-group", side === "left" ? leftGroupText : rightGroupText) + .attr("data-anchor", `row-${safeDimension}-${side}-card-centerline`) + .attr("data-collision-rule", "stay inside the row card, outside bar/value labels/year-axis text, and share the row centerline") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bbox", `${(iconCx - rowIconRadius).toFixed(1)},${(cy - rowIconRadius).toFixed(1)},${(rowIconRadius * 2).toFixed(1)},${(rowIconRadius * 2).toFixed(1)}`); + + icon.append("circle") + .attr("cx", iconCx) + .attr("cy", cy) + .attr("r", rowIconRadius) + .attr("fill", side === "left" ? "#E7EFDF" : "#E8EEF6") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 2) + .attr("opacity", 0.96); + icon.append("circle") + .attr("cx", iconCx) + .attr("cy", cy) + .attr("r", Math.max(5, rowIconRadius * 0.28)) + .attr("fill", "none") + .attr("stroke", color) + .attr("stroke-width", 2) + .attr("opacity", 0.72); + } + + dimensions.forEach((dimension) => { + const cy = rowCenter(dimension); + const y = cy - barHeight / 2; + const formattedDimension = dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}`; + + rowCardAndIcon("left", dimension, formattedDimension, cy, leftColor); + rowCardAndIcon("right", dimension, formattedDimension, cy, rightColor); + + const centerPillW = centerPillMaxW; + const centerPillH = temporalDimension + ? Math.max(30, Math.min(38, rowBand * 0.56)) + : Math.max(24, Math.min(34, rowBand * 0.48)); + const dimensionFont = temporalDimension + ? Math.max(17, Math.min(25, centerPillH * 0.62)) + : Math.max(9, Math.min(14, centerPillH * 0.42)); + const displayDimension = temporalDimension + ? formattedDimension + : ellipsizeToWidth(formattedDimension, centerPillW - 13, dimensionFont); + + svg.append("rect") + .attr("class", "hdbar05-center-label-pill") + .attr("data-dimension", formattedDimension) + .attr("data-relationship", "centerline-aligned-to-vertical-spine") + .attr("x", centerX - centerPillW / 2) + .attr("y", cy - centerPillH / 2) + .attr("width", centerPillW) + .attr("height", centerPillH) + .attr("rx", Math.min(10, centerPillH * 0.34)) + .attr("fill", darkGreen) + .attr("stroke", "#F3E2A7") + .attr("stroke-width", 1.1); + + const dimensionText = svg.append("text") + .attr("class", "hdbar05-center-label-text") + .attr("data-full-label", formattedDimension) + .attr("x", centerX) + .attr("y", cy + dimensionFont * 0.36) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", dimensionFont) + .attr("font-weight", 700) + .attr("fill", "#FFFFFF") + .text(displayDimension); + fitText(dimensionText, centerPillW - 12, temporalDimension ? 14 : 8); + + const leftData = byKey.get(`${dimension}|||${leftGroup}`); + const rightData = byKey.get(`${dimension}|||${rightGroup}`); + if (leftData) { + const v = Math.max(0, +leftData[valueField] || 0); + const w = Math.max(2, leftScale(v)); + const x = leftAxisStart; + const labelText = formatValue(v); + const labelFontSize = Math.max(15, Math.min(29, rowBand * 0.42)); + svg.append("path") + .attr("class", "bar left-bar") + .attr("data-dimension", formattedDimension) + .attr("data-group", leftGroupText) + .attr("data-value", v) + .attr("d", barPath(x, y, w, barHeight)) + .attr("fill", "url(#hdbar05-left-gradient)") + .attr("stroke", d3.color(leftColor).darker(0.8).formatHex()) + .attr("stroke-width", 1.2) + .attr("filter", "url(#hdbar05-soft-shadow)"); + svg.append("text") + .attr("class", "label value-label left") + .attr("x", x + w + 12) + .attr("y", cy + 8) + .attr("text-anchor", "start") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", labelFontSize) + .attr("font-weight", 700) + .attr("fill", darkGreen) + .text(labelText); + } + if (rightData) { + const v = Math.max(0, +rightData[valueField] || 0); + const w = Math.max(2, rightScale(v)); + const x = rightAxisStart; + const labelText = formatValue(v); + const labelFontSize = Math.max(15, Math.min(29, rowBand * 0.42)); + svg.append("path") + .attr("class", "bar right-bar") + .attr("data-dimension", formattedDimension) + .attr("data-group", rightGroupText) + .attr("data-value", v) + .attr("d", barPath(x, y, w, barHeight)) + .attr("fill", "url(#hdbar05-right-gradient)") + .attr("stroke", d3.color(rightColor).darker(0.7).formatHex()) + .attr("stroke-width", 1.2) + .attr("filter", "url(#hdbar05-soft-shadow)"); + svg.append("text") + .attr("class", "label value-label right") + .attr("x", x - 14) + .attr("y", cy + 8) + .attr("text-anchor", "end") + .attr("font-family", "Georgia, Times New Roman, serif") + .attr("font-size", labelFontSize) + .attr("font-weight", 700) + .attr("fill", rightColor) + .text(labelText); + } + }); + + const slotY = height * 0.775; + ["left", "right"].forEach((side) => { + const x = side === "left" ? width * 0.08 : width * 0.75; + const w = width * 0.18; + const slot = svg.append("g") + .attr("class", `reserved-asset-slot hdbar05-architecture-slot ${side}`) + .attr("data-asset-slot", `${side}-architecture-background`) + .attr("data-slot-policy", "image2_asset_or_retrieval_asset") + .attr("data-asset-source-policy", "image2_asset_or_retrieval_asset") + .attr("data-anchor", `${side}-lower-chart-background`) + .attr("data-collision-rule", "remain behind chart-owned content; hide before overlapping data text or row slots") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-bbox", `${x.toFixed(1)},${slotY.toFixed(1)},${w.toFixed(1)},${(height * 0.115).toFixed(1)}`) + .attr("opacity", 0); + slot.append("rect").attr("x", x).attr("y", slotY).attr("width", w).attr("height", height * 0.115).attr("rx", 8).attr("fill", "none").attr("stroke", "none"); + }); + + svg.append("metadata").text(JSON.stringify({ + variation: "horizontal_diverging_bar_chart_05", + selected_reference_geometry: { + temporal_order: temporalDimension ? "chronological ascending" : "input order", + bar_endpoint: "chamfered/slanted outer value edge, flat inner baseline edge, non-stacked", + bar_baseline_relationship: "left bars share common left baseline after row icon region and extend rightward by value; right bars share common left baseline after blue value labels", + value_labels: "green values outside/adjacent to green bar value ends; blue values just before/adjacent to blue bar starts", + row_cards: "pale rounded row-local containers spanning each bar row and aligned to row centerlines", + row_icon_slots: "per-row circular semantic reserved slots on both sides with bbox/anchor/collision metadata", + center_axis_labels: "dark-green rounded pills aligned to the center spine; temporal labels remain chronological and non-temporal labels are truncated inside the pill", + measure_headers: "top left/right measure headers above bar columns; no bottom 0-100 axes because selected reference does not show them", + bottom_wrappers: "ignored", + copied_assets: "none; asset-like regions are reserved slots only" + } + })); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_06.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_06.js new file mode 100644 index 0000000000000000000000000000000000000000..981968623aab4fa528a2582340c2333dbc928f33 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_06.js @@ -0,0 +1,687 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_06", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group", "group2"], + "hierarchy":["group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, 10000], [1, 5], [1, 3]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "replace", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 全面优化的Split Comparison Chart实现 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "24px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "16px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 设置默认视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : true; + variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; + variables.has_gradient = variables.has_gradient !== undefined ? variables.has_gradient : false; + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : true; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸 + const width = variables.width || 900; + // 动态调整高度以适应所有数据 + const rowHeight = 50; // 减小行高以容纳更多数据 + const initialMargin = { top: 60, right: 40, bottom: 40, left: 40 }; + + // 提取字段名称 + const xField = chartUtils.schema.channel(jsonData, "x").key; + const yField = chartUtils.schema.channel(jsonData, "y").key; + + + + // 使用第一个 group 作为 categoryField，如果不存在则使用默认值 + const categoryField = chartUtils.schema.channel(jsonData, "group").key; + + // 使用第二个 group 作为 developmentStatusField，如果不存在则使用默认值 + const developmentStatusField = chartUtils.schema.channel(jsonData, "group2").key; + + // 获取唯一维度和类别 + const allDimensions = [...new Set(chartData.map(d => d[xField]))]; + const allLeaveTypes = [...new Set(chartData.map(d => d[categoryField]))]; + const allDevelopmentStatuses = [...new Set(chartData.map(d => d[developmentStatusField]))]; + + // 确定左右两组的类别 + let leftCategory, rightCategory; + + if (allLeaveTypes.length >= 2) { + // 如果没有预期的值，但有至少两个类别，使用前两个 + leftCategory = allLeaveTypes[0]; + rightCategory = allLeaveTypes[1]; + } else { + // 默认值 + leftCategory = "Left Category"; + rightCategory = "Right Category"; + } + + // 创建左右两侧数据 + const leftData = {}; + const rightData = {}; + + // 处理数据 + chartData.forEach(item => { + const dimension = item[xField]; + const value = item[yField]; + const category = item[categoryField]; + const developmentStatus = item[developmentStatusField]; // 获取发展状态 + + // 左侧组数据 + if (category === leftCategory) { + leftData[dimension] = { + dimension: dimension, + value: value, + developmentStatus: developmentStatus // 保存发展状态 + }; + } + + // 右侧组数据 + if (category === rightCategory) { + rightData[dimension] = { + dimension: dimension, + value: value, + developmentStatus: developmentStatus // 保存发展状态 + }; + } + }); + + // 对左右两组数据独立排序（按值从大到小） + const sortedLeftData = Object.values(leftData) + .sort((a, b) => b.value - a.value); + + const sortedRightData = Object.values(rightData) + .sort((a, b) => b.value - a.value); + + // 确定行数（左右两侧中较长的一个） + const rowCount = Math.max(sortedLeftData.length, sortedRightData.length); + + // 动态计算整体高度 + const height = initialMargin.top + (rowCount * rowHeight) + initialMargin.bottom; + + // 计算实际图表区域尺寸 + const margin = initialMargin; + const innerWidth = width - margin.left - margin.right; + const innerHeight = rowCount * rowHeight; + + // 设置布局参数 + const centerX = innerWidth / 2; + const rankCircleRadius = 18; // 缩小排名圆圈 + const itemIconWidth = 40; // 缩小图标宽度 + const itemIconHeight = 43; // 缩小图标高度 + + // ---------- 3. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 处理背景设置 + if (jsonData.variation?.background === "styled") { + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "#f9f9f9"); + } else { + // 添加原有的背景 - 使用棋盘格图案 + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#checkerboard)"); + } + + // ---------- 4. 文本测量辅助函数 ---------- + + // 计算文本宽度的函数 + const calculateTextWidth = (text, fontSize, fontWeight, fontFamily) => { + return chartUtils.text.measure(svg, text, { + fontFamily: fontFamily || typography.label.font_family, + fontSize: fontSize || typography.label.font_size, + fontWeight: fontWeight || typography.label.font_weight + }).width; + }; + + // ---------- 5. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 创建颜色获取函数 - 修改为同时考虑类别和发展状态 + const getColor = (category, developmentStatus, index) => { + // 基础颜色 - 左侧为绿色，右侧为蓝色 + let baseColor; + + const fallbackColor = colorResolver.available(index, { cycle: true, fallback: category === leftCategory ? "#4BB462" : "#5271C7" }).value; + baseColor = colorResolver.field(category, index, { fallback: fallbackColor }).value; + + // 根据发展状态调整颜色深浅 + if (developmentStatus === allDevelopmentStatuses[0]) { + // 深色版本 - 对于已发展国家 + return baseColor; + } else { + // 浅色版本 - 对于发展中国家 + // 将颜色转换为RGB，然后调亮 + const rgb = d3.rgb(baseColor); + return d3.rgb( + Math.min(255, rgb.r + 60), + Math.min(255, rgb.g + 60), + Math.min(255, rgb.b + 60) + ).toString(); + } + }; + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 创建阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 2); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 创建渐变效果（如果启用） + if (variables.has_gradient) { + // 左侧渐变 + const leftGradientId = `gradient-${leftCategory.replace(/\s+/g, '-').toLowerCase()}`; + const leftBaseColor = getColor(leftCategory, allDevelopmentStatuses[0], 0); + + const leftGradient = defs.append("linearGradient") + .attr("id", leftGradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + leftGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(leftBaseColor, { mode: "brighter", amount: 1.2 })); + + leftGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(leftBaseColor, { mode: "darker", amount: 0.7 })); + + // 右侧渐变 + const rightGradientId = `gradient-${rightCategory.replace(/\s+/g, '-').toLowerCase()}`; + const rightBaseColor = getColor(rightCategory, allDevelopmentStatuses[0], 0); + + const rightGradient = defs.append("linearGradient") + .attr("id", rightGradientId) + .attr("x1", "100%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "0%"); + + rightGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(rightBaseColor, { mode: "brighter", amount: 1.2 })); + + rightGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(rightBaseColor, { mode: "darker", amount: 0.7 })); + } + + // ---------- 6. 计算状态标签宽度 ---------- + + // 计算所有可能的发展状态标签宽度 + const statusLabelWidths = {}; + allDevelopmentStatuses.forEach(status => { + // 使用小字体(12px)计算状态标签的宽度 + statusLabelWidths[status] = calculateTextWidth(status.toUpperCase(), "12px", "normal"); + }); + + // 获取最大标签宽度，加上一些间距作为安全边距 + const maxStatusLabelWidth = Math.max(...Object.values(statusLabelWidths)); + + // ---------- 7. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left},${margin.top})`); + + // 添加左右两侧的标题 + let leftCategoryName = leftCategory; + let rightCategoryName = rightCategory; + + // 左右圆圈的起始X位置 + const leftRankX = 0; + const rightRankX = centerX + maxStatusLabelWidth - 20; + + // 计算标题文本的宽度 + let fontSize = typography.label.font_size; + let fontSizeValue = parseFloat(fontSize); + let leftTextWidth = calculateTextWidth(leftCategoryName, fontSize); + let rightTextWidth = calculateTextWidth(rightCategoryName, fontSize); + + // 计算每侧可用的最大宽度 + const leftMaxWidth = centerX - 20; + const rightMaxWidth = centerX - 20; + + // 根据需要缩小字体，直到文本适合最大宽度 + // 同时确保左右标题使用相同的字体大小 + const minFontSize = 10; + while ((leftTextWidth > leftMaxWidth || rightTextWidth > rightMaxWidth) && + fontSizeValue > minFontSize) { + // 减小字体大小 + fontSizeValue -= 1; + fontSize = fontSizeValue + "px"; + leftTextWidth = calculateTextWidth(leftCategoryName, fontSize); + rightTextWidth = calculateTextWidth(rightCategoryName, fontSize); + } + + // 计算标题矩形的宽度，确保适合文本 + const leftRectWidth = leftTextWidth + 10; // 在文本两侧添加一些填充 + const rightRectWidth = rightTextWidth + 10; + + // 左侧标题 - 与左侧圆圈对齐 + const leftTitleGroup = g.append("g") + .attr("transform", `translate(${leftRankX}, -20)`); + + leftTitleGroup.append("rect") + .attr("x", 0) + .attr("y", -15) + .attr("width", leftRectWidth) + .attr("height", 25) + .attr("fill", "#000"); + + leftTitleGroup.append("text") + .attr("x", leftRectWidth / 2) + .attr("y", 0) + .attr("text-anchor", "middle") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", fontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", "#fff") + .text(leftCategoryName); + + // 右侧标题 - 与右侧圆圈对齐 + const rightTitleGroup = g.append("g") + .attr("transform", `translate(${rightRankX}, -20)`); + + rightTitleGroup.append("rect") + .attr("x", 0) + .attr("y", -15) + .attr("width", rightRectWidth) + .attr("height", 25) + .attr("fill", "#000"); + + rightTitleGroup.append("text") + .attr("x", rightRectWidth / 2) + .attr("y", 0) + .attr("text-anchor", "middle") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", fontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", "#fff") + .text(rightCategoryName); + + // ---------- 8. 创建数据可视化 ---------- + + // 添加交替行背景 + if (jsonData.variation?.background === "styled") { + sortedLeftData.forEach((item, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", i * rowHeight) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", rowHeight) + .attr("class", "background") + .attr("fill", "#f5f5f5") + .attr("opacity", 0.8); + } + }); + } + + // 找出所有数据中的最大值，确保左右两侧使用统一比例尺 + const allValues = [...sortedLeftData.map(d => d.value), ...sortedRightData.map(d => d.value)]; + const globalMaxValue = Math.max(...allValues); + + // 左侧排名圆圈和图标所占空间 + const leftIconSpace = rankCircleRadius * 3 + itemIconWidth + 10; + + // 右侧排名圆圈和图标所占空间 + const rightIconSpace = rankCircleRadius * 3 + itemIconWidth + 10; + + // 左侧安全边距 + const leftSafetyMargin = 10; + + // 右侧安全边距 (包括状态标签的宽度) + const rightSafetyMargin = maxStatusLabelWidth + 15; + + // 计算左右两侧可用的最大宽度 + const leftMaxBarWidth = centerX - leftIconSpace - leftSafetyMargin; + const rightMaxBarWidth = centerX - rightIconSpace - leftSafetyMargin; + + // 创建统一的柱状图比例尺 - 左侧 + const leftBarScale = d3.scaleLinear() + .domain([0, globalMaxValue]) + .range([0, leftMaxBarWidth]); + + // 创建统一的柱状图比例尺 - 右侧 + // 使用相同的比例关系，确保左右两侧相同值的柱子长度相同 + const rightBarScale = d3.scaleLinear() + .domain([0, globalMaxValue]) + .range([0, rightMaxBarWidth]); + + // 用于跟踪左侧已经显示过的发展状态 + const leftShownStatusLabels = new Set(); + + // 绘制左侧条目 + sortedLeftData.forEach((item, index) => { + const dimension = item.dimension; + const value = item.value; + const developmentStatus = item.developmentStatus; + const yPos = index * rowHeight; // 此行的起始y位置 + + // 8.1 绘制排名圆圈和数字 + const rankX = 20; + const rankY = yPos + rowHeight / 2; + + const rankGroup = g.append("g") + .attr("transform", `translate(${rankX}, ${rankY})`); + + rankGroup.append("circle") + .attr("r", rankCircleRadius) + .attr("fill", "#000"); + + rankGroup.append("text") + .attr("text-anchor", "middle") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight",typography.label.font_weight) + .style("fill", "#fff") + .text(index + 1); + + // 8.2 添加维度图标（如国家标志）- 紧接圆圈右边 + const iconX = rankX + rankCircleRadius + 3; + const iconY = rankY - itemIconHeight / 2; + + // 如果有图标则使用 + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", itemIconWidth) + .attr("height", itemIconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 8.3 显示左侧值（柱状图） + const barStartX = iconX + itemIconWidth + 5; + const barWidth = leftBarScale(value); // 根据值计算长度 + const barHeight = rowHeight * 0.85; + const barY = yPos + (rowHeight - barHeight) / 2; + const boxColor = getColor(leftCategory, developmentStatus, index); + const FontSize = Math.floor(barHeight * 0.5) + "px"; + + // 确定填充颜色，考虑渐变效果 + const fillColor = variables.has_gradient ? + `url(#gradient-${leftCategory.replace(/\s+/g, '-').toLowerCase()})` : + boxColor; + + // 绘制值框 - 使用原始矩形形状 + g.append("rect") + .attr("x", barStartX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", variables.has_rounded_corners ? 5 : 0) + .attr("ry", variables.has_rounded_corners ? 5 : 0) + .attr("fill", fillColor) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // For the left bar values: + // First, calculate the text width + const leftFormattedValue = `${chartUtils.format.autoText(value)}${valueUnit}`; + + // Get text width + const leftTextWidth = chartUtils.text.measure(g, leftFormattedValue, { + fontFamily: typography.label.font_family, + fontSize: FontSize, + fontWeight: typography.label.font_weight + }).width; + + // Define minimum width needed for text to fit comfortably + const leftMinWidthForText = leftTextWidth + 10; // Add padding + + // Check if bar is wide enough for text + if (barWidth < leftMinWidthForText) { + // Bar too narrow - place text outside left edge + g.append("text") + .attr("x", barStartX + barWidth + 16) // Position right of the bar + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "end") // Right align + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", FontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // Use default text color + .text(leftFormattedValue); + } else { + // Bar wide enough - place text inside + g.append("text") + .attr("x", barStartX + barWidth - leftTextWidth) + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "middle") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", FontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", "#fff") // White text for inside bar + .text(leftFormattedValue); + } + + // 如果此发展状态尚未显示过标签，则添加 + if (!leftShownStatusLabels.has(developmentStatus)) { + leftShownStatusLabels.add(developmentStatus); + + g.append("text") + .attr("x", barStartX + barWidth + 5) + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "start") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", "12px") + .style("font-weight",typography.label.font_weight) + .style("fill", boxColor) + .text(developmentStatus.toUpperCase()); + } + }); + + // 用于跟踪右侧已经显示过的发展状态 + const rightShownStatusLabels = new Set(); + + // 绘制右侧条目 + sortedRightData.forEach((item, index) => { + const dimension = item.dimension; + const value = item.value; + const developmentStatus = item.developmentStatus; + const yPos = index * rowHeight; // 此行的起始y位置 + + // 8.1 绘制排名圆圈和数字 + const rankX = centerX + maxStatusLabelWidth - 25; + const rankY = yPos + rowHeight / 2; + + // 8.2 添加维度图标（如国家标志）- 紧接圆圈右边 + const iconX = rankX + 3; + const iconY = rankY - itemIconHeight / 2; + + // 如果有图标则使用 + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", itemIconWidth) + .attr("height", itemIconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 8.3 显示右侧值（柱状图） + const barStartX = iconX + itemIconWidth + 5; + const barWidth = rightBarScale(value); // 根据值计算长度 + const barHeight = rowHeight * 0.85; + const barY = yPos + (rowHeight - barHeight) / 2; + const boxColor = getColor(rightCategory, developmentStatus, index); + const FontSize = Math.floor(barHeight * 0.5) + "px"; + + // 确定填充颜色，考虑渐变效果 + const fillColor = variables.has_gradient ? + `url(#gradient-${rightCategory.replace(/\s+/g, '-').toLowerCase()})` : + boxColor; + + // 绘制值框 - 使用原始矩形形状 + g.append("rect") + .attr("x", barStartX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("rx", variables.has_rounded_corners ? 5 : 0) + .attr("ry", variables.has_rounded_corners ? 5 : 0) + .attr("fill", fillColor) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // For the right bar values: + // First, calculate the text width + const rightFormattedValue = `${chartUtils.format.autoText(value)}${valueUnit}`; + + // Get text width + const rightTextWidth = chartUtils.text.measure(g, rightFormattedValue, { + fontFamily: typography.label.font_family, + fontSize: FontSize, + fontWeight: typography.label.font_weight + }).width; + + // Define minimum width needed for text to fit comfortably + const rightMinWidthForText = rightTextWidth + 10; // Add padding + + // Check if bar is wide enough for text + if (barWidth < rightMinWidthForText) { + // Bar too narrow - place text outside right edge + g.append("text") + .attr("x", barStartX + barWidth + 5) // Position right of the bar + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "start") // Left align + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", FontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // Use default text color + .text(rightFormattedValue); + } else { + // Bar wide enough - place text inside + g.append("text") + .attr("x", barStartX + barWidth - rightTextWidth ) + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "middle") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", FontSize) + .style("font-weight", typography.label.font_weight) + .style("fill", "#fff") // White text for inside bar + .text(rightFormattedValue); + } + + // 如果此发展状态尚未显示过标签，则添加 + if (!rightShownStatusLabels.has(developmentStatus)) { + rightShownStatusLabels.add(developmentStatus); + + // 将标签固定在预留的空间内，避免与柱状图重叠 + g.append("text") + .attr("x", barStartX + barWidth + 5) + .attr("y", barY + barHeight / 2) + .attr("text-anchor", "start") + .attr("dy", "0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", "12px") + .style("font-weight",typography.label.font_weight) + .style("fill", boxColor) + .text(developmentStatus.toUpperCase()); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_07.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_07.js new file mode 100644 index 0000000000000000000000000000000000000000..2b5c3956135d77a884d2220c2c68049954984ae0 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_07.js @@ -0,0 +1,747 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_07", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical", "temporal"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const rows = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const width = +variables.width || 1024; + const height = +variables.height || 1536; + const columns = chartUtils.schema.columns(jsonData); + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + const valueUnit = valueChannel.unit && valueChannel.unit !== "none" ? valueChannel.unit : ""; + const dimensionUnit = dimensionChannel.unit && dimensionChannel.unit !== "none" ? dimensionChannel.unit : ""; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "horizontal_diverging_bar_chart_07") + .attr("data-reference-policy", "code-generated-layout-no-embedded-raster"); + + const defs = svg.append("defs"); + defs.append("filter") + .attr("id", "hdbar07-card-shadow") + .attr("x", "-12%") + .attr("y", "-8%") + .attr("width", "124%") + .attr("height", "116%") + .html(` + + + `); + + const pageGradient = defs.append("linearGradient") + .attr("id", "hdbar07-page-bg") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "100%"); + pageGradient.append("stop").attr("offset", "0%").attr("stop-color", "#F4FBFF"); + pageGradient.append("stop").attr("offset", "100%").attr("stop-color", "#DCEEFF"); + + function makeLinearGradient(id, c0, c1) { + const grad = defs.append("linearGradient") + .attr("id", id) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + grad.append("stop").attr("offset", "0%").attr("stop-color", c0); + grad.append("stop").attr("offset", "100%").attr("stop-color", c1); + } + makeLinearGradient("hdbar07-green-bar", "#7DD957", "#44A83D"); + makeLinearGradient("hdbar07-blue-bar", "#367BF4", "#1257D8"); + makeLinearGradient("hdbar07-row", "#FFFFFF", "#F8FCFF"); + makeLinearGradient("hdbar07-metric", "#F8FCFF", "#FFFFFF"); + + const columnByName = new Map(columns.map(col => [col.name, col])); + const isTemporalDimension = /temporal|date|time/i.test(String((columnByName.get(dimensionField) || {}).data_type || "")); + const monthRank = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, + sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, + dec: 12, december: 12 + }; + + function temporalRank(value) { + const s = String(value).trim(); + const numeric = Number(s); + if (/^\d{4}$/.test(s)) return numeric; + const date = Date.parse(s); + if (!Number.isNaN(date)) return date; + const lower = s.toLowerCase(); + if (monthRank[lower]) return monthRank[lower]; + const yearMatch = lower.match(/\b(19|20)\d{2}\b/); + if (yearMatch) return Number(yearMatch[0]); + return s; + } + + const groups = Array.from(new Set(rows.map(d => d[groupField]))).slice(0, 2); + const leftGroup = groups[0] || "Group A"; + const rightGroup = groups[1] || "Group B"; + const dimensions = Array.from(new Set(rows.map(d => d[dimensionField]))).sort((a, b) => { + if (!isTemporalDimension && !/year|month|date|season|quarter/i.test(dimensionField)) { + return rows.findIndex(d => d[dimensionField] === a) - rows.findIndex(d => d[dimensionField] === b); + } + const ar = temporalRank(a); + const br = temporalRank(b); + if (typeof ar === "number" && typeof br === "number") return ar - br; + return String(ar).localeCompare(String(br), undefined, { numeric: true }); + }); + const dimensionLabels = new Map(dimensions.map(dimension => [ + dimension, + dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}` + ])); + const maxDimensionLabelChars = d3.max(Array.from(dimensionLabels.values()).map(label => String(label).length)) || 0; + + const byDimGroup = new Map(); + rows.forEach(d => { + byDimGroup.set(`${d[dimensionField]}|||${d[groupField]}`, d); + }); + + function valueFor(dimension, group) { + const row = byDimGroup.get(`${dimension}|||${group}`); + return row ? Math.max(0, +row[valueField] || 0) : 0; + } + + const values = rows.map(d => Math.max(0, +d[valueField] || 0)); + const maxValue = Math.max(1, d3.max(values) || 1); + const maxLeftValue = Math.max(1, d3.max(rows.filter(d => d[groupField] === leftGroup), d => Math.max(0, +d[valueField] || 0)) || 1); + const maxRightValue = Math.max(1, d3.max(rows.filter(d => d[groupField] === rightGroup), d => Math.max(0, +d[valueField] || 0)) || 1); + + function displayValue(value) { + const formatted = chartUtils.format.autoText(value); + return valueUnit ? `${formatted}${valueUnit}` : formatted; + } + + function fittedFontSize(text, maxWidth, baseSize, minSize, factor = 0.58) { + const length = Math.max(1, String(text || "").length); + return Math.max(minSize, Math.min(baseSize, maxWidth / (length * factor))); + } + + function measuredTextWidth(text, fontSize, fontWeight, fontFamily) { + const label = String(text || ""); + const probe = svg.append("text") + .attr("x", -9999) + .attr("y", -9999) + .attr("font-family", fontFamily || "Arial, sans-serif") + .attr("font-size", fontSize) + .attr("font-weight", fontWeight || 400) + .attr("visibility", "hidden") + .text(label); + let widthEstimate; + try { + widthEstimate = probe.node().getComputedTextLength(); + } catch (e) { + widthEstimate = label.length * fontSize * 0.62; + } + probe.remove(); + return Number.isFinite(widthEstimate) && widthEstimate > 0 + ? widthEstimate + : label.length * fontSize * 0.62; + } + + function truncateToWidth(text, maxWidth, fontSize, fontWeight, fontFamily) { + const label = String(text || ""); + if (measuredTextWidth(label, fontSize, fontWeight, fontFamily) <= maxWidth) return label; + let lo = 0; + let hi = label.length; + while (lo < hi) { + const mid = Math.ceil((lo + hi) / 2); + const candidate = `${label.slice(0, mid).trimEnd()}...`; + if (measuredTextWidth(candidate, fontSize, fontWeight, fontFamily) <= maxWidth) { + lo = mid; + } else { + hi = mid - 1; + } + } + return `${label.slice(0, Math.max(1, lo)).trimEnd()}...`; + } + + function wrapWordsToWidth(text, maxWidth, fontSize, fontWeight, fontFamily, maxLines) { + const words = String(text || "").trim().split(/\s+/).filter(Boolean); + if (!words.length) return [""]; + const lines = []; + let line = ""; + words.forEach(word => { + const candidate = line ? `${line} ${word}` : word; + if (!line || measuredTextWidth(candidate, fontSize, fontWeight, fontFamily) <= maxWidth) { + line = candidate; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + return lines; + } + + function wrapWordsToWidthWithFallback(text, maxWidth, fontSize, fontWeight, fontFamily, maxLines) { + const lines = wrapWordsToWidth(text, maxWidth, fontSize, fontWeight, fontFamily, maxLines); + if (lines.length <= maxLines) { + return lines.map(ln => truncateToWidth(ln, maxWidth, fontSize, fontWeight, fontFamily)); + } + const kept = lines.slice(0, maxLines - 1); + const tail = lines.slice(maxLines - 1).join(" "); + kept.push(truncateToWidth(tail, maxWidth, fontSize, fontWeight, fontFamily)); + return kept; + } + + function headerLabelLayout(text, maxWidth) { + const fontFamily = "Arial, sans-serif"; + const fontWeight = 900; + for (let size = 35; size >= 20; size -= 1) { + const singleLineWidth = measuredTextWidth(text, size, fontWeight, fontFamily); + if (singleLineWidth <= maxWidth) { + return { lines: [String(text || "")], size, lineHeight: size * 0.96, family: fontFamily }; + } + const lines = wrapWordsToWidth(text, maxWidth, size, fontWeight, fontFamily, 2); + const maxLineWidth = d3.max(lines.map(line => measuredTextWidth(line, size, fontWeight, fontFamily))) || 0; + if (lines.length <= 2 && maxLineWidth <= maxWidth) { + return { lines, size, lineHeight: size * 0.96, family: fontFamily }; + } + } + const size = 20; + return { + lines: wrapWordsToWidthWithFallback(text, maxWidth, size, fontWeight, fontFamily, 2), + size, + lineHeight: size * 0.96, + family: fontFamily + }; + } + + function maxValueLabelChars(group) { + return d3.max(dimensions.map(dimension => displayValue(valueFor(dimension, group)).length)) || 0; + } + + function groupColor(group, side) { + const resolved = colorResolver.field(group, 0, { fallbackKey: side === "left" ? "positive" : "primary" }).value; + if (/android|sustainable|natural|green/i.test(String(group))) return "#2D8F2F"; + if (/ios|nfl|blue|digital/i.test(String(group))) return "#1358D6"; + return resolved || (side === "left" ? "#2D8F2F" : "#1358D6"); + } + + const leftColor = groupColor(leftGroup, "left"); + const rightColor = groupColor(rightGroup, "right"); + const navy = "#10284F"; + const blue = "#175FE8"; + const muted = "#556174"; + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#hdbar07-page-bg)"); + + const card = { + x: width * 0.028, + y: height * 0.022, + w: width * 0.944, + h: height * 0.953 + }; + + svg.append("rect") + .attr("x", card.x) + .attr("y", card.y) + .attr("width", card.w) + .attr("height", card.h) + .attr("rx", 18) + .attr("fill", "#FFFFFF") + .attr("stroke", "#C8DDF3") + .attr("stroke-width", 1.2) + .attr("filter", "url(#hdbar07-card-shadow)"); + + svg.append("rect") + .attr("x", card.x + 18) + .attr("y", card.y + 24) + .attr("width", card.w - 36) + .attr("height", card.h - 48) + .attr("rx", 14) + .attr("fill", "#F9FDFF") + .attr("opacity", 0.32); + + function appendSlot(parent, cfg) { + const g = parent.append("g") + .attr("class", `reserved-asset-slot ${cfg.className || ""}`) + .attr("data-asset-slot", cfg.slot) + .attr("data-slot-policy", "neutral_placeholder_or_image2_asset") + .attr("data-asset-source-policy", "neutral_placeholder_or_image2_asset") + .attr("data-anchor", cfg.anchor) + .attr("data-collision-rule", cfg.collision) + .attr("data-bbox", `${cfg.x.toFixed(2)},${cfg.y.toFixed(2)},${cfg.size.toFixed(2)},${cfg.size.toFixed(2)}`) + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("transform", `translate(${cfg.x},${cfg.y})`); + g.append("circle") + .attr("cx", cfg.size / 2) + .attr("cy", cfg.size / 2) + .attr("r", cfg.size / 2 - 2) + .attr("fill", cfg.fill || "#EEF6FF") + .attr("stroke", cfg.stroke || "#B8D0EF") + .attr("stroke-width", 2) + .attr("stroke-dasharray", cfg.dash || "none"); + if (cfg.label) { + g.append("text") + .attr("x", cfg.size / 2) + .attr("y", cfg.size / 2 + cfg.size * 0.13) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", cfg.size * 0.34) + .attr("font-weight", 800) + .attr("fill", cfg.textColor || muted) + .text(cfg.label); + } + return g; + } + + appendSlot(svg, { + slot: "title-art-icon", + className: "title-art-icon-slot", + x: width / 2 - 41, + y: 8, + size: 82, + fill: "#FFFFFF", + stroke: "#C8DDF3", + dash: "7 6", + anchor: "top-center-card-edge", + collision: "overlap-card-edge-only;avoid-title-text", + label: "" + }); + + function splitTitle(title) { + const words = String(title || "").trim().split(/\s+/).filter(Boolean); + if (words.length <= 4) return [words.join(" "), ""]; + const preferred = words.findIndex(w => /^(in|by|from|than|vs\\.?|versus)$/i.test(w)); + const cut = preferred > 1 && preferred < words.length - 1 ? preferred : Math.ceil(words.length / 2); + return [words.slice(0, cut).join(" "), words.slice(cut).join(" ")]; + } + + function addWrappedText(parent, text, x, y, maxChars, lineHeight, attrs) { + const words = String(text || "").trim().split(/\s+/).filter(Boolean); + const lines = []; + let line = ""; + words.forEach(word => { + const candidate = line ? `${line} ${word}` : word; + if (candidate.length <= maxChars || !line) { + line = candidate; + } else { + lines.push(line); + line = word; + } + }); + if (line) lines.push(line); + const t = parent.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", attrs.anchor || "middle") + .attr("font-family", attrs.family || "Arial, sans-serif") + .attr("font-size", attrs.size) + .attr("font-weight", attrs.weight || 400) + .attr("fill", attrs.fill || muted) + .attr("letter-spacing", "0"); + lines.slice(0, attrs.maxLines || 3).forEach((ln, i) => { + t.append("tspan") + .attr("x", x) + .attr("dy", i === 0 ? 0 : lineHeight) + .text(ln); + }); + return lines.length; + } + + const titleText = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || + "Horizontal Diverging Bar Chart"; + const subtitleText = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || ""; + const titleLines = splitTitle(titleText.toUpperCase()); + const longestTitleLine = Math.max(titleLines[0].length, titleLines[1].length); + const titleMaxWidth = card.w - 120; + const titleSize = Math.min(width < 760 ? 42 : 58, Math.max(36, titleMaxWidth / Math.max(1, longestTitleLine * 0.60))); + const titleTop = card.y + 102; + + svg.append("text") + .attr("x", width / 2) + .attr("y", titleTop) + .attr("text-anchor", "middle") + .attr("font-family", "Arial Narrow, Arial, sans-serif") + .attr("font-size", titleSize) + .attr("font-weight", 900) + .attr("fill", navy) + .attr("letter-spacing", "0") + .text(titleLines[0]); + svg.append("text") + .attr("x", width / 2) + .attr("y", titleTop + titleSize * 1.18) + .attr("text-anchor", "middle") + .attr("font-family", "Arial Narrow, Arial, sans-serif") + .attr("font-size", titleSize * 0.92) + .attr("font-weight", 900) + .attr("fill", blue) + .attr("letter-spacing", "0") + .text(titleLines[1] || ""); + + const dividerY = titleTop + titleSize * 1.82; + svg.append("line") + .attr("x1", width / 2 - 42) + .attr("x2", width / 2 + 42) + .attr("y1", dividerY) + .attr("y2", dividerY) + .attr("stroke", blue) + .attr("stroke-width", 5) + .attr("stroke-linecap", "round"); + + addWrappedText(svg, subtitleText, width / 2, dividerY + 42, 46, 34, { + size: 27, + fill: "#344051", + family: "Arial, sans-serif", + weight: 400, + maxLines: 2 + }); + + const headerY = card.y + 390; + const plot = { + x: card.x + 38, + y: card.y + 500, + w: card.w - 76, + h: Math.min(card.h * 0.49, height - card.y - 660) + }; + const metricY = plot.y + plot.h + 34; + const metricH = Math.max(108, Math.min(140, card.y + card.h - metricY - 84)); + const rowGap = Math.max(13, Math.min(22, plot.h / Math.max(10, dimensions.length * 3.1))); + const rowStep = plot.h / Math.max(1, dimensions.length); + const rowH = Math.max(34, Math.min(94, rowStep - rowGap)); + const barH = Math.max(18, Math.min(56, rowH * 0.48)); + const centerX = width / 2; + const baseRailW = Math.max(86, width * 0.095); + const railW = maxDimensionLabelChars > 6 + ? Math.max(baseRailW, Math.min(width * 0.22, Math.max(124, maxDimensionLabelChars * 10.2))) + : baseRailW; + const railLeft = centerX - railW / 2; + const railRight = centerX + railW / 2; + const leftValueX = plot.x + Math.max(62, width * 0.07); + const rightValueX = plot.x + plot.w - Math.max(24, width * 0.025); + const leftBarEnd = railLeft - 20; + const rightBarStart = railRight + 26; + const leftLabelChars = maxValueLabelChars(leftGroup); + const rightLabelChars = maxValueLabelChars(rightGroup); + const denseLeftValueGap = leftLabelChars > 5 ? Math.max(158, width * 0.158) : Math.max(92, width * 0.11); + const denseRightValueGap = rightLabelChars > 5 ? Math.max(152, width * 0.148) : Math.max(96, width * 0.092); + const leftBarStartMin = leftValueX + denseLeftValueGap; + const rightBarMaxW = rightValueX - rightBarStart - denseRightValueGap; + const leftBarMaxW = leftBarEnd - leftBarStartMin; + const minBarW = Math.max(48, width * 0.06); + const leftBarScale = d3.scaleLinear() + .domain([0, maxLeftValue]) + .range([minBarW, Math.max(minBarW, leftBarMaxW)]); + const rightBarScale = d3.scaleLinear() + .domain([0, maxRightValue]) + .range([minBarW, Math.max(minBarW, rightBarMaxW)]); + const valueFontSize = Math.max(22, Math.min(34, rowH * 0.39, (leftLabelChars > 5 || rightLabelChars > 5) ? 27 : 34)); + const dimensionFontSize = Math.max(15, Math.min(27, rowH * 0.34, railW / Math.max(1, maxDimensionLabelChars * 0.58))); + const barCornerRadius = Math.max(5, Math.min(9, barH * 0.18)); + + function addHeader(side, group, x, color, slot) { + const iconSize = 94; + appendSlot(svg, { + slot, + className: `${side}-group-icon-slot`, + x, + y: headerY, + size: iconSize, + fill: side === "left" ? "#E7F6DE" : "#E7F0FF", + stroke: side === "left" ? "#D7EBCD" : "#D6E3FA", + anchor: `${side}-group-header-leading-circle`, + collision: "stay-above-plot-rows-and-inside-card", + label: String(group).trim().slice(0, 1).toUpperCase(), + textColor: color + }); + const tx = x + iconSize + 28; + const groupLabel = String(group).toUpperCase(); + const groupMaxWidth = side === "left" + ? Math.max(90, railLeft - tx - 22) + : Math.max(90, card.x + card.w - tx - 30); + const groupLayout = headerLabelLayout(groupLabel, groupMaxWidth); + const groupTitleY = headerY + (groupLayout.lines.length > 1 ? 38 : 48); + const groupText = svg.append("text") + .attr("x", tx) + .attr("y", groupTitleY) + .attr("font-family", groupLayout.family) + .attr("font-size", groupLayout.size) + .attr("font-weight", 900) + .attr("fill", color) + .attr("text-anchor", "start"); + groupLayout.lines.forEach((line, index) => { + groupText.append("tspan") + .attr("x", tx) + .attr("dy", index === 0 ? 0 : groupLayout.lineHeight) + .text(line); + }); + const subtitleY = Math.min(headerY + 96, groupTitleY + (groupLayout.lines.length - 1) * groupLayout.lineHeight + 33); + svg.append("text") + .attr("x", tx) + .attr("y", subtitleY) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 22) + .attr("font-weight", 400) + .attr("fill", "#344051") + .attr("text-anchor", "start") + .text(valueUnit ? `${valueField.replace(/([a-z])([A-Z])/g, "$1 $2")} (${valueUnit})` : valueField.replace(/([a-z])([A-Z])/g, "$1 $2")); + } + + addHeader("left", leftGroup, plot.x + 26, leftColor, "left-group-icon"); + addHeader("right", rightGroup, rightBarStart + 12, rightColor, "right-group-icon"); + + svg.append("text") + .attr("x", centerX) + .attr("y", headerY + 88) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 22) + .attr("font-weight", 800) + .attr("fill", "#3A4658") + .text(String(dimensionField).toUpperCase()); + + const railTop = plot.y + 12; + const railBottom = plot.y + plot.h - 12; + + dimensions.forEach((dimension, i) => { + const rowY = plot.y + i * rowStep + (rowStep - rowH) / 2; + const cy = rowY + rowH / 2; + svg.append("rect") + .attr("x", plot.x) + .attr("y", rowY) + .attr("width", plot.w) + .attr("height", rowH) + .attr("rx", Math.min(16, rowH * 0.22)) + .attr("fill", "url(#hdbar07-row)") + .attr("stroke", "#EDF4FC") + .attr("stroke-width", 1); + + const leftValue = valueFor(dimension, leftGroup); + const rightValue = valueFor(dimension, rightGroup); + const leftW = Math.min(leftBarMaxW, leftBarScale(leftValue)); + const rightW = Math.min(rightBarMaxW, rightBarScale(rightValue)); + const leftX = leftBarEnd - leftW; + const rightX = rightBarStart; + + svg.append("text") + .attr("x", leftValueX) + .attr("y", cy + 9) + .attr("text-anchor", "start") + .attr("font-family", "Arial Narrow, Arial, sans-serif") + .attr("font-size", valueFontSize) + .attr("font-weight", 800) + .attr("fill", leftColor) + .text(displayValue(leftValue)); + + svg.append("rect") + .attr("class", "bar bar-left") + .attr("data-dimension", String(dimension)) + .attr("data-group", String(leftGroup)) + .attr("data-value", leftValue) + .attr("x", leftX) + .attr("y", cy - barH / 2) + .attr("width", Math.max(2, leftW)) + .attr("height", barH) + .attr("rx", barCornerRadius) + .attr("ry", barCornerRadius) + .attr("fill", "url(#hdbar07-green-bar)") + .attr("stroke", "#3E9D35") + .attr("stroke-width", 1); + + svg.append("rect") + .attr("x", leftX + 4) + .attr("y", cy - barH / 2 + 3) + .attr("width", Math.max(0, leftW - 10)) + .attr("height", Math.max(2, barH * 0.26)) + .attr("rx", barH * 0.13) + .attr("fill", "#A4EA84") + .attr("opacity", 0.24) + .attr("pointer-events", "none"); + + svg.append("text") + .attr("x", centerX) + .attr("y", cy + 8) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", dimensionFontSize) + .attr("font-weight", 500) + .attr("fill", "#3D4758") + .text(dimensionLabels.get(dimension)); + + svg.append("rect") + .attr("class", "bar bar-right") + .attr("data-dimension", String(dimension)) + .attr("data-group", String(rightGroup)) + .attr("data-value", rightValue) + .attr("x", rightX) + .attr("y", cy - barH / 2) + .attr("width", Math.max(2, rightW)) + .attr("height", barH) + .attr("rx", barCornerRadius) + .attr("ry", barCornerRadius) + .attr("fill", "url(#hdbar07-blue-bar)") + .attr("stroke", "#145BD6") + .attr("stroke-width", 1); + + svg.append("rect") + .attr("x", rightX + 4) + .attr("y", cy - barH / 2 + 3) + .attr("width", Math.max(0, rightW - 10)) + .attr("height", Math.max(2, barH * 0.26)) + .attr("rx", barH * 0.13) + .attr("fill", "#6BA2FF") + .attr("opacity", 0.24) + .attr("pointer-events", "none"); + + svg.append("text") + .attr("x", rightValueX) + .attr("y", cy + 9) + .attr("text-anchor", "end") + .attr("font-family", "Arial Narrow, Arial, sans-serif") + .attr("font-size", valueFontSize) + .attr("font-weight", 800) + .attr("fill", rightColor) + .text(displayValue(rightValue)); + }); + + [railLeft, railRight].forEach(x => { + svg.append("line") + .attr("x1", x) + .attr("x2", x) + .attr("y1", railTop) + .attr("y2", railBottom) + .attr("stroke", "#D3E2F3") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "8 12") + .attr("pointer-events", "none"); + }); + + function growthFor(group) { + const firstDim = dimensions[0]; + const lastDim = dimensions[dimensions.length - 1]; + const first = valueFor(firstDim, group); + const last = valueFor(lastDim, group); + if (!first) return null; + return { + firstDim, + lastDim, + pct: ((last - first) / first) * 100 + }; + } + + const metricX = plot.x; + const metricW = plot.w; + const metric = svg.append("g") + .attr("class", "chart-owned-growth-metric-strip") + .attr("data-chart-owned-annotation", "growth-from-first-to-last-dimension") + .attr("data-no-bottom-source-footer", "true") + .attr("data-ignored-reference-footer", "source-line-omitted"); + + metric.append("rect") + .attr("x", metricX) + .attr("y", metricY) + .attr("width", metricW) + .attr("height", metricH) + .attr("rx", 16) + .attr("fill", "url(#hdbar07-metric)") + .attr("stroke", "#BFD8F6") + .attr("stroke-width", 1.4); + metric.append("line") + .attr("x1", metricX + metricW / 2) + .attr("x2", metricX + metricW / 2) + .attr("y1", metricY + 25) + .attr("y2", metricY + metricH - 25) + .attr("stroke", "#BFD8F6") + .attr("stroke-width", 2); + + function addMetric(side, group, color, x0, slotName) { + const growth = growthFor(group); + const iconSize = Math.min(70, metricH - 38); + appendSlot(metric, { + slot: slotName, + className: `${side}-growth-icon-slot`, + x: x0 + 42, + y: metricY + (metricH - iconSize) / 2, + size: iconSize, + fill: side === "left" ? "#E2F4D9" : "#E4F0FF", + stroke: side === "left" ? "#C8E7BC" : "#C7DCF8", + dash: "6 5", + anchor: `${side}-growth-metric-strip`, + collision: "stay-inside-growth-strip-and-below-plot", + label: "", + textColor: color + }); + const labelX = x0 + 138; + const topText = growth ? `${growth.firstDim} \u2192 ${growth.lastDim} GROWTH` : "GROWTH"; + metric.append("text") + .attr("x", labelX) + .attr("y", metricY + 42) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 21) + .attr("font-weight", 800) + .attr("fill", "#344051") + .text(topText); + metric.append("text") + .attr("x", labelX) + .attr("y", metricY + 92) + .attr("font-family", "Arial Narrow, Arial, sans-serif") + .attr("font-size", 45) + .attr("font-weight", 900) + .attr("fill", color) + .text(growth ? `${growth.pct >= 0 ? "+" : ""}${Math.round(growth.pct)}%` : ""); + const groupLabelX = labelX + 160; + const groupLabelMaxWidth = side === "left" + ? Math.max(70, x0 + metricW / 2 - groupLabelX - 28) + : Math.max(70, metricX + metricW - groupLabelX - 28); + const metricGroupFontSize = fittedFontSize(String(group), groupLabelMaxWidth, 25, 13, 0.56); + metric.append("text") + .attr("x", groupLabelX) + .attr("y", metricY + 92) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", metricGroupFontSize) + .attr("font-weight", 500) + .attr("fill", color) + .text(String(group)); + } + + addMetric("left", leftGroup, leftColor, metricX, "growth-icon-left"); + addMetric("right", rightGroup, rightColor, metricX + metricW / 2, "growth-icon-right"); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_08.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_08.js new file mode 100644 index 0000000000000000000000000000000000000000..157573c0b79ce1349cf45869779b2bd396b39260 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_08.js @@ -0,0 +1,524 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_08", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const rootData = data || {}; + const chartData = Array.isArray(rootData.data?.data) + ? rootData.data.data + : (Array.isArray(rootData.data) ? rootData.data : []); + const variables = rootData.variables || {}; + const typography = rootData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colorResolver = chartUtils.color.resolver(rootData); + + d3.select(containerSelector).html(""); + + const width = Number(variables.width) || 800; + const height = Number(variables.height) || 600; + const labelFamily = typography.label?.font_family || "Arial"; + const valueFamily = typography.annotation?.font_family || labelFamily; + const textColor = colorResolver.text({ fallback: "#101828" }).value; + const mutedText = colorResolver.variant(textColor, { mode: "brighter", amount: 2.8 }); + const leftAccent = colorResolver.other("left_accent", { fallback: "#F59E0B" }).value || "#F59E0B"; + const rightAccent = colorResolver.other("right_accent", { fallback: "#E84D67" }).value || "#E84D67"; + const centerAccent = "#5B78F6"; + + function schemaChannel(channel, fallback) { + try { + return chartUtils.schema.channel(rootData, channel); + } catch (error) { + return fallback; + } + } + + const dimensionChannel = schemaChannel("x", { key: "category", unit: "" }); + const valueChannel = schemaChannel("y", { key: "value", unit: "" }); + const groupChannel = schemaChannel("group", { key: "group", unit: "" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + const valueUnit = valueChannel.unit || ""; + const dimensionLabel = (dimensionChannel.name || dimensionField || "Category").replace(/([a-z])([A-Z])/g, "$1 $2"); + + const rawGroups = [...new Set(chartData.map(d => d[groupField]).filter(d => d != null))]; + if (rawGroups.length < 2 || chartData.length === 0) { + return d3.select(containerSelector).append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .node(); + } + + const leftGroup = rawGroups[0]; + const rightGroup = rawGroups[1]; + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]).filter(d => d != null))]; + const leftRank = new Map(chartData + .filter(d => d[groupField] === leftGroup) + .map(d => [d[dimensionField], Number(d[valueField]) || 0])); + const dimensions = allDimensions.slice().sort((a, b) => { + const diff = (leftRank.get(b) || 0) - (leftRank.get(a) || 0); + return diff !== 0 ? diff : String(a).localeCompare(String(b)); + }); + + const rowByDimension = dimensions.map((dimension) => { + const left = chartData.find(d => d[dimensionField] === dimension && d[groupField] === leftGroup); + const right = chartData.find(d => d[dimensionField] === dimension && d[groupField] === rightGroup); + return { + dimension, + leftValue: left ? Number(left[valueField]) || 0 : 0, + rightValue: right ? Number(right[valueField]) || 0 : 0, + leftDatum: left || null, + rightDatum: right || null + }; + }); + + const maxLeftValue = Math.max(1, d3.max(rowByDimension, d => d.leftValue) || 1); + const maxRightValue = Math.max(1, d3.max(rowByDimension, d => d.rightValue) || 1); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-template", "horizontal_diverging_bar_chart_08") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", "hdbc08-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "150%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 4) + .attr("stdDeviation", 5) + .attr("flood-color", "#9AA4B2") + .attr("flood-opacity", 0.18); + + const leftGradient = defs.append("linearGradient") + .attr("id", "hdbc08-left-gradient") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + leftGradient.append("stop").attr("offset", "0%").attr("stop-color", "#FDBA3B"); + leftGradient.append("stop").attr("offset", "100%").attr("stop-color", leftAccent); + + const rightGradient = defs.append("linearGradient") + .attr("id", "hdbc08-right-gradient") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + rightGradient.append("stop").attr("offset", "0%").attr("stop-color", "#EF6275"); + rightGradient.append("stop").attr("offset", "100%").attr("stop-color", rightAccent); + + const marginX = Math.max(24, width * 0.045); + const marginTop = Math.max(10, height * 0.018); + const marginBottom = Math.max(14, height * 0.025); + const headerH = Math.max(46, Math.min(68, height * 0.105)); + const headerGap = Math.max(9, height * 0.018); + const plotX = marginX; + const plotW = width - marginX * 2; + const plotY = marginTop; + const rowsY = plotY + headerH + headerGap; + const rowsH = height - rowsY - marginBottom; + const n = Math.max(1, rowByDimension.length); + const rowGap = Math.max(3, Math.min(7, rowsH / n * 0.09)); + const rowH = Math.max(20, (rowsH - rowGap * (n - 1)) / n); + const dense = rowH < 40; + let valueFont = Math.max(10, Math.min(22, rowH * (dense ? 0.34 : 0.44))); + const labelFont = Math.max(8, Math.min(16, rowH * (dense ? 0.28 : 0.32))); + const headerFont = Math.max(8, Math.min(13, headerH * 0.22)); + const iconR = Math.max(8, Math.min(22, rowH * 0.33)); + const barH = Math.max(5, Math.min(24, rowH * 0.28)); + const barRadius = Math.max(2, Math.min(4, barH * 0.18)); + + const formatValue = (value) => { + const formatted = chartUtils.format.autoText(value); + return valueUnit ? `${formatted}${valueUnit}` : `${formatted}`; + }; + + const measure = (value, fontSize, family = valueFamily, weight = 700) => { + return chartUtils.text.measure(null, String(value), { + fontFamily: family, + fontSize, + fontWeight: weight + }).width; + }; + + const maxLeftLabelWRaw = d3.max(rowByDimension, d => measure(formatValue(d.leftValue), valueFont)) || 0; + const maxRightLabelWRaw = d3.max(rowByDimension, d => measure(formatValue(d.rightValue), valueFont)) || 0; + const maxValueReserve = plotW * (dense ? 0.15 : 0.18); + const rawMaxValueW = Math.max(maxLeftLabelWRaw, maxRightLabelWRaw); + if (rawMaxValueW > maxValueReserve) { + valueFont = Math.max(9, valueFont * Math.max(0.62, maxValueReserve / rawMaxValueW)); + } + const maxLeftLabelW = d3.max(rowByDimension, d => measure(formatValue(d.leftValue), valueFont)) || 0; + const maxRightLabelW = d3.max(rowByDimension, d => measure(formatValue(d.rightValue), valueFont)) || 0; + const gap = Math.max(8, plotW * 0.012); + const leftValueW = Math.min(plotW * 0.19, Math.max(plotW * 0.10, maxLeftLabelW + 12)); + const rightValueW = Math.min(plotW * 0.19, Math.max(plotW * 0.10, maxRightLabelW + 12)); + const centerW = Math.min(plotW * 0.36, Math.max(plotW * 0.30, plotW * (dense ? 0.31 : 0.34))); + const barW = Math.max(36, (plotW - leftValueW - rightValueW - centerW - gap * 4) / 2); + const centerX = plotX + leftValueW + gap + barW + gap; + const col = { + leftValueX: plotX + leftValueW - 4, + leftBarX: plotX + leftValueW + gap, + leftBarW: barW, + centerX: centerX, + centerW: centerW, + rightBarX: centerX + centerW + gap, + rightBarW: barW, + rightValueX: centerX + centerW + gap + barW + gap + }; + + const truncate = (value, maxWidth, fontSize, weight = 700) => { + return chartUtils.text.truncate(String(value), maxWidth, { + fontFamily: labelFamily, + fontSize, + fontWeight: weight + }); + }; + + const headerLabel = (value) => String(value) + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim() + .toUpperCase(); + const textLengthOrNull = (value, maxWidth, fontSize, family = labelFamily, weight = 800) => { + const w = measure(value, fontSize, family, weight); + return w > maxWidth ? maxWidth : null; + }; + const splitHeaderLines = (text, maxChars = 14) => { + const words = String(text || "").split(/\s+/).filter(Boolean); + if (words.join(" ").length <= maxChars || words.length <= 1) return [words.join(" ")]; + const lines = []; + let current = ""; + words.forEach((word) => { + if (!current) { + current = word; + } else if ((current + " " + word).length <= maxChars || lines.length >= 1) { + current += " " + word; + } else { + lines.push(current); + current = word; + } + }); + if (current) lines.push(current); + return lines.slice(0, 2); + }; + const appendHeaderText = (parent, cfg) => { + const lines = splitHeaderLines(cfg.text, cfg.maxChars); + const fontSize = lines.length > 1 ? Math.max(7, headerFont * 0.72) : headerFont; + const text = parent.append("text") + .attr("x", cfg.x) + .attr("y", cfg.y) + .attr("text-anchor", cfg.anchor || "start") + .attr("fill", cfg.fill) + .attr("font-family", labelFamily) + .attr("font-size", fontSize) + .attr("font-weight", 800) + .attr("letter-spacing", lines.length > 1 ? 0.15 : (cfg.letterSpacing ?? 0.5)); + lines.forEach((line, i) => { + text.append("tspan") + .attr("x", cfg.x) + .attr("dy", i === 0 ? (lines.length > 1 ? "-0.18em" : "0.35em") : "1.18em") + .text(line); + }); + return text; + }; + const leftHeaderText = headerLabel(leftGroup); + const centerHeaderText = headerLabel(dimensionLabel); + const rightHeaderText = headerLabel(rightGroup); + const centerHeaderMaxW = plotW * 0.25; + + const table = svg.append("g") + .attr("class", "reference-card-table") + .attr("data-reference-local-geometry", "grid-aligned-row-cards-shared-centerlines"); + + table.append("rect") + .attr("class", "chart-panel") + .attr("x", plotX - 2) + .attr("y", plotY - 2) + .attr("width", plotW + 4) + .attr("height", height - plotY - marginBottom + 4) + .attr("rx", 18) + .attr("ry", 18) + .attr("fill", "#FFFFFF") + .attr("stroke", "#E6EAF2") + .attr("stroke-width", 1) + .style("filter", "url(#hdbc08-soft-shadow)"); + + const header = table.append("g") + .attr("class", "segmented-header") + .attr("data-coordinate-relationship", "flush-with-row-card-grid"); + header.append("rect") + .attr("x", plotX + 8) + .attr("y", plotY + 6) + .attr("width", plotW - 16) + .attr("height", headerH - 12) + .attr("rx", (headerH - 12) / 2) + .attr("ry", (headerH - 12) / 2) + .attr("fill", "#FFF6E3") + .attr("stroke", "#F3E9D6"); + header.append("rect") + .attr("x", plotX + plotW * 0.35) + .attr("y", plotY + 6) + .attr("width", plotW * 0.30) + .attr("height", headerH - 12) + .attr("rx", (headerH - 12) / 2) + .attr("ry", (headerH - 12) / 2) + .attr("fill", "#FFFFFF") + .attr("stroke", "#EEF1F6") + .style("filter", "url(#hdbc08-soft-shadow)"); + header.append("rect") + .attr("x", plotX + plotW * 0.62) + .attr("y", plotY + 6) + .attr("width", plotW * 0.38 - 8) + .attr("height", headerH - 12) + .attr("rx", (headerH - 12) / 2) + .attr("ry", (headerH - 12) / 2) + .attr("fill", "#FDECF0") + .attr("stroke", "#F7D5DC"); + + function drawLegendIcon(group, cx, cy, side) { + const accent = side === "left" ? leftAccent : rightAccent; + header.append("circle") + .attr("cx", cx) + .attr("cy", cy) + .attr("r", Math.max(11, headerH * 0.24)) + .attr("fill", "#FFFFFF") + .attr("stroke", accent) + .attr("stroke-width", 1.3); + header.append("path") + .attr("d", side === "left" + ? `M ${cx - 6} ${cy + 5} C ${cx - 2} ${cy - 5}, ${cx + 2} ${cy - 8}, ${cx + 7} ${cy - 10} C ${cx + 5} ${cy - 2}, ${cx + 1} ${cy + 4}, ${cx - 6} ${cy + 5} Z` + : `M ${cx - 7} ${cy - 4} L ${cx + 2} ${cy - 8} L ${cx + 2} ${cy + 8} L ${cx - 7} ${cy + 4} Z M ${cx + 4} ${cy - 4} L ${cx + 8} ${cy - 2} L ${cx + 8} ${cy + 2} L ${cx + 4} ${cy + 4} Z`) + .attr("fill", accent) + .attr("opacity", 0.9); + } + + const headerCy = plotY + headerH / 2; + drawLegendIcon(leftGroup, plotX + plotW * 0.11, headerCy, "left"); + drawLegendIcon(rightGroup, plotX + plotW * 0.74, headerCy, "right"); + + appendHeaderText(header, { + x: plotX + plotW * 0.18, + y: headerCy, + text: leftHeaderText, + fill: leftAccent, + maxChars: 14, + letterSpacing: 0.5 + }); + header.append("text") + .attr("x", plotX + plotW * 0.50) + .attr("y", headerCy) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .attr("fill", "#384152") + .attr("font-family", labelFamily) + .attr("font-size", headerFont) + .attr("font-weight", 800) + .attr("letter-spacing", 0.7) + .attr("textLength", textLengthOrNull(centerHeaderText, centerHeaderMaxW, headerFont)) + .attr("lengthAdjust", textLengthOrNull(centerHeaderText, centerHeaderMaxW, headerFont) ? "spacingAndGlyphs" : null) + .text(centerHeaderText); + appendHeaderText(header, { + x: plotX + plotW * 0.89, + y: headerCy, + text: rightHeaderText, + fill: rightAccent, + anchor: "middle", + maxChars: 8, + letterSpacing: 0.5 + }); + + const rows = table.selectAll(".comparison-row") + .data(rowByDimension) + .enter() + .append("g") + .attr("class", "comparison-row") + .attr("data-coordinate-relationship", "grid-aligned-row-centerline") + .attr("data-category", d => d.dimension) + .attr("transform", (d, i) => `translate(0,${rowsY + i * (rowH + rowGap)})`); + + rows.append("rect") + .attr("class", "row-card") + .attr("x", plotX) + .attr("y", 0) + .attr("width", plotW) + .attr("height", rowH) + .attr("rx", Math.min(14, rowH * 0.22)) + .attr("ry", Math.min(14, rowH * 0.22)) + .attr("fill", "#FFFFFF") + .attr("stroke", "#E9EDF5") + .attr("stroke-width", 1) + .style("filter", rowH >= 30 ? "url(#hdbc08-soft-shadow)" : "none"); + + rows.append("line") + .attr("x1", col.centerX - gap * 0.8) + .attr("x2", col.centerX - gap * 0.8) + .attr("y1", 2) + .attr("y2", rowH - 2) + .attr("stroke", "#E5EAF2") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 3") + .attr("opacity", dense ? 0.35 : 0.65); + rows.append("line") + .attr("x1", col.centerX + col.centerW + gap * 0.8) + .attr("x2", col.centerX + col.centerW + gap * 0.8) + .attr("y1", 2) + .attr("y2", rowH - 2) + .attr("stroke", "#E5EAF2") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 3") + .attr("opacity", dense ? 0.35 : 0.65); + + rows.append("text") + .attr("class", "left-value-label") + .attr("x", col.leftValueX) + .attr("y", rowH / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .attr("fill", leftAccent) + .attr("font-family", valueFamily) + .attr("font-size", valueFont) + .attr("font-weight", 700) + .text(d => formatValue(d.leftValue)); + + rows.append("rect") + .attr("class", "left-bar") + .attr("data-group", String(leftGroup)) + .attr("data-value", d => d.leftValue) + .attr("data-bar-endpoint-geometry", "slight-rounded-rectangle-not-pill") + .attr("x", d => col.leftBarX + col.leftBarW - (d.leftValue / maxLeftValue) * col.leftBarW) + .attr("y", rowH / 2 - barH / 2) + .attr("width", d => Math.max(d.leftValue > 0 ? 3 : 0, (d.leftValue / maxLeftValue) * col.leftBarW)) + .attr("height", barH) + .attr("rx", barRadius) + .attr("ry", barRadius) + .attr("fill", "url(#hdbc08-left-gradient)"); + + const iconGroup = rows.append("g") + .attr("class", "category-icon-slot") + .attr("data-asset-slot", "category-icon") + .attr("data-slot-policy", "image2_asset_with_neutral_placeholder") + .attr("data-anchor", "row-centerline-before-category-label") + .attr("data-collision-rule", "inside-center-column-left-of-label-avoid-bars-values-dividers") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("data-slot-bbox", d => { + const cx = col.centerX + iconR + 2; + const cy = rowH / 2; + return `${Math.round(cx - iconR)},${Math.round(cy - iconR)},${Math.round(iconR * 2)},${Math.round(iconR * 2)}`; + }); + + iconGroup.append("circle") + .attr("cx", col.centerX + iconR + 2) + .attr("cy", rowH / 2) + .attr("r", iconR) + .attr("fill", "#EEF3FF") + .attr("stroke", "#DFE7FF") + .attr("stroke-width", 1); + + iconGroup.each(function(d) { + const group = d3.select(this); + const cx = col.centerX + iconR + 2; + const cy = rowH / 2; + group.append("text") + .attr("x", cx) + .attr("y", cy) + .attr("dy", "0.36em") + .attr("text-anchor", "middle") + .attr("font-family", labelFamily) + .attr("font-size", Math.max(7, iconR * 0.85)) + .attr("font-weight", 800) + .attr("fill", centerAccent) + .text(String(d.dimension).charAt(0).toUpperCase()); + }); + + rows.append("text") + .attr("class", "category-label") + .attr("x", col.centerX + iconR * 2 + 12) + .attr("y", rowH / 2) + .attr("dy", "0.35em") + .attr("fill", "#0F1733") + .attr("font-family", labelFamily) + .attr("font-size", labelFont) + .attr("font-weight", 800) + .attr("textLength", d => textLengthOrNull( + String(d.dimension), + Math.max(12, col.centerW - iconR * 2 - 18), + labelFont, + labelFamily, + 800 + )) + .attr("lengthAdjust", d => textLengthOrNull( + String(d.dimension), + Math.max(12, col.centerW - iconR * 2 - 18), + labelFont, + labelFamily, + 800 + ) ? "spacingAndGlyphs" : null) + .text(d => String(d.dimension)); + + rows.append("rect") + .attr("class", "right-bar") + .attr("data-group", String(rightGroup)) + .attr("data-value", d => d.rightValue) + .attr("data-bar-endpoint-geometry", "slight-rounded-rectangle-not-pill") + .attr("x", col.rightBarX) + .attr("y", rowH / 2 - barH / 2) + .attr("width", d => Math.max(d.rightValue > 0 ? 3 : 0, (d.rightValue / maxRightValue) * col.rightBarW)) + .attr("height", barH) + .attr("rx", barRadius) + .attr("ry", barRadius) + .attr("fill", "url(#hdbc08-right-gradient)"); + + rows.append("text") + .attr("class", "right-value-label") + .attr("x", d => Math.min(col.rightValueX, col.rightBarX + (d.rightValue / maxRightValue) * col.rightBarW + 10)) + .attr("y", rowH / 2) + .attr("dy", "0.35em") + .attr("fill", rightAccent) + .attr("font-family", valueFamily) + .attr("font-size", valueFont) + .attr("font-weight", 700) + .text(d => formatValue(d.rightValue)); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_09.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_09.js new file mode 100644 index 0000000000000000000000000000000000000000..94bdfddffa30c0882ac5ca2cfe54bb4af245e982 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_09.js @@ -0,0 +1,377 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_09", + "is_composite": false, + "required_fields": ["x", "y", "group", "group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"],["categorical"]], + "required_fields_range": [[2, 20], [0, 100], [2, 2],[2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group", "group2"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js - 改为水平对比分组条形图 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间 + const titleHeight = 120; // 为标题和图例预留更多高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题和图例空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 80 // 左侧足够显示数值 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0, fallbackKey: "Parent Type" }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1, fallbackKey: "Percentage" }); + const groupChannel = chartUtils.schema.channel(jsonData, "group", { fallbackIndex: 2, fallbackKey: "Gender" }); + const group2Channel = chartUtils.schema.channel(jsonData, "group2", { fallbackIndex: 3, fallbackKey: "Career Impact" }); + const parentTypeField = xChannel.key; + const valueField = yChannel.key; + const genderField = groupChannel.key; + const careerImpactField = group2Channel.key; + const valueUnit = yChannel.unit || ""; + + // ---------- 4. 数据处理 ---------- + + // 获取各维度的唯一值 + const parentTypes = [...new Set(chartData.map(d => d[parentTypeField]))]; + const genders = [...new Set(chartData.map(d => d[genderField]))]; + const careerImpacts = [...new Set(chartData.map(d => d[careerImpactField]))]; + + // 确保只有两个性别分组（用于水平对比） + if (genders.length !== 2) { + console.error("The gender field must have exactly 2 unique values for this chart type"); + return; + } + + // 动态分配左右两侧的性别 + const leftGender = genders[1]; + const rightGender = genders[0]; + + // ---------- 5. 计算标签和图表空间 ---------- + + // 创建临时SVG用于测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算文本宽度的函数 + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(tempSvg, text, { fontFamily: fontFamily, fontSize: parseFloat(fontSize) || fontSize, fontWeight: fontWeight }).width; + } + + // 计算最大值标签的宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const valueText = `${d[valueField]}${valueUnit}`; + const textWidth = measureTextWidth( + valueText, + typography.annotation.font_family, + typography.annotation.font_size, + typography.annotation.font_weight + ); + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 为值标签预留空间 + margin.left = Math.max(margin.left, maxValueWidth + 20); + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算总分组数（每个career impact有多个parent types） + const totalGroups = careerImpacts.length; + + // 计算标签所需的垂直空间 + const labelFontSize = parseInt(typography.label.font_size) || 16; + const labelSpace = labelFontSize + 10; // 标签高度 + 额外间距 + + // 每个careerImpact组的高度 + const impactGroupHeight = innerHeight / totalGroups; + // 组间距 + const groupPadding = (labelFontSize + variables.has_spacing ? impactGroupHeight * 0.2 : impactGroupHeight * 0.1); + const subGroupHeight = (impactGroupHeight - groupPadding) / parentTypes.length; + // 实际条形高度 (减去标签空间) + const barHeight = variables.has_spacing ? subGroupHeight - labelFontSize - subGroupHeight * 0.5 : subGroupHeight - labelFontSize - subGroupHeight * 0.4; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + genders.forEach(gender => { + const gradientId = `gradient-${gender.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGenderColor(gender); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 1.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.7 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 - 中心位置为0，向两侧延伸 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth / 2]); // 每侧占用一半宽度 + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 图表的中心线位置 + const centerX = innerWidth / 2; + + // ---------- 9. 绘制图例 ---------- + + // 获取性别颜色 + function getGenderColor(gender) { + // 优先使用指定颜色 + if (colorResolver.field(gender, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(gender, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + const genderIndex = genders.indexOf(gender); + const availableColor = colorResolver.available(genderIndex, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + + // 默认颜色方案 + const defaultColors = { + "Men": "#efb118", // 橙色 + "Women": "#a463f2" // 紫色 + }; + + return defaultColors[gender] || "#999"; + } + chartUtils.legend.mirrorPair(svg, { label: leftGender, color: getGenderColor(leftGender) }, { label: rightGender, color: getGenderColor(rightGender) }, { + centerX: width / 2, + y: margin.top * 0.8, + circleRadius: 8, + circleTextGap: 8, + centerMargin: 14, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: "bold", + textColor: colorResolver.text({ fallback: "#333" }).value, + }); + // ---------- 10. 绘制分组条形图 ---------- + + // 为每个Career Impact创建分组 + careerImpacts.forEach((impact, impactIndex) => { + // 计算该Impact组的垂直位置 + const impactGroupY = impactIndex * impactGroupHeight; + + // 绘制Impact标题 - 居中显示并增加间距 + const titleFontSize = 24; // 标题使用较大字体 + const titleOffset = titleFontSize + 20; // 标题高度 + 额外间距 + + g.append("text") + .attr("x", centerX) + .attr("y", impactGroupY + groupPadding - 20) + .attr("text-anchor", "middle") + .style("font-family", typography.title.font_family) + .style("font-size", `${labelFontSize+1}px`) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(impact); + + // 为每个Parent Type绘制条形 + parentTypes.forEach((parentType, parentIndex) => { + // 计算该Parent Type的垂直位置 + const barY = impactGroupY + groupPadding + parentIndex * subGroupHeight + subGroupHeight *0.1; + + // 绘制Parent Type标签 - 居中显示并确保不与条形图重叠 + + + g.append("text") + .attr("x", centerX) + .attr("y", barY ) // 使用动态计算的间距 + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(parentType); + + // 处理每个性别的数据 + genders.forEach((gender) => { + // 查找数据点 + const dataPoint = chartData.find(d => + d[parentTypeField] === parentType && + d[genderField] === gender && + d[careerImpactField] === impact + ); + + if (dataPoint) { + // 获取数值 + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 确定条形位置和方向 + let barX, textX, textAnchor; + if (gender === leftGender) { + // 左侧性别 - 向左延伸 + barX = centerX - barWidth; + textX = barX - 10; + textAnchor = "end"; + } else { + // 右侧性别 - 向右延伸 + barX = centerX; + textX = barX + barWidth + 10; + textAnchor = "start"; + } + + // 绘制条形 + g.append("rect") + .attr("x", barX) + .attr("y", barY + labelFontSize / 2) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${gender.replace(/\s+/g, '-').toLowerCase()})` : + getGenderColor(gender)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? "#333" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${barHeight * 0.6}px`; + // 显示数值 + g.append("text") + .attr("x", textX) + .attr("y", barY + labelFontSize / 2 + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(`${chartUtils.format.autoText(value)}${valueUnit}`); + } + }); + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..602e89d297aa1f2a4e40e442a890a0a31138fdbf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_10.js @@ -0,0 +1,523 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_10", + "is_composite": false, + "chart_for": "comparison", + "required_fields": ["x", "y", "group","group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"],["categorical"]], + "required_fields_range": [[2, 20], [0, 100], [2, 2],[2, 5]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + subtitle: { font_family: "Arial", font_size: "16px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + + d3.select(containerSelector).html(""); + + const width = variables.width || 600; + const height = variables.height || 600; + const uid = "hdbc10"; + + const xChannel = chartUtils.schema.channel(jsonData, "x"); + const yChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const group2Channel = chartUtils.schema.channel(jsonData, "group2"); + + const topicField = xChannel.key; + const valueField = yChannel.key; + const opinionGroupField = groupChannel.key; + const supporterGroupField = group2Channel.key; + const valueUnit = yChannel.unit || ""; + + function uniqueInOrder(values) { + const seen = new Set(); + const out = []; + values.forEach(value => { + const key = String(value); + if (!seen.has(key)) { + seen.add(key); + out.push(value); + } + }); + return out; + } + + function temporalRank(value) { + if (value == null) return Number.POSITIVE_INFINITY; + if (typeof value === "number" && Number.isFinite(value)) return value; + const text = String(value).trim(); + const numeric = Number(text); + if (Number.isFinite(numeric)) return numeric; + const parsed = Date.parse(text); + if (Number.isFinite(parsed)) return parsed; + const months = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, + apr: 4, april: 4, may: 5, jun: 6, june: 6, jul: 7, july: 7, + aug: 8, august: 8, sep: 9, sept: 9, september: 9, oct: 10, + october: 10, nov: 11, november: 11, dec: 12, december: 12 + }; + return months[text.toLowerCase()] || Number.POSITIVE_INFINITY; + } + + const isTemporalTopic = (xChannel.type || xChannel.data_type || "").toLowerCase() === "temporal" || + /year|date|month|season|time/i.test(topicField || ""); + + const topics = uniqueInOrder(chartData.map(d => d[topicField])); + if (isTemporalTopic) { + topics.sort((a, b) => temporalRank(a) - temporalRank(b)); + } + + const opinionGroups = uniqueInOrder(chartData.map(d => d[opinionGroupField])); + const supporterGroups = uniqueInOrder(chartData.map(d => d[supporterGroupField])); + + if (!topicField || !valueField || !opinionGroupField || !supporterGroupField || opinionGroups.length !== 2) { + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("xmlns", "http://www.w3.org/2000/svg"); + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "14px") + .style("fill", colorResolver.text({ fallback: "#28304a" }).value) + .text("Horizontal diverging bar requires two groups."); + return svg.node(); + } + + const valuesByKey = new Map(); + chartData.forEach(d => { + const key = `${d[topicField]}|||${d[supporterGroupField]}|||${d[opinionGroupField]}`; + valuesByKey.set(key, +d[valueField]); + }); + + const globalMaxValue = d3.max(chartData, d => +d[valueField]) || 1; + const scaleMax = globalMaxValue * 1.08; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto; overflow: visible;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + svg.append("metadata") + .attr("data-asset-slot", "header-reserved-slots") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .text(JSON.stringify({ + slots: [ + { + name: "header-left-media-icon", + anchor: "header safe area", + bbox_ratio: { x: 0.03, y: 0.07, w: 0.11, h: 0.08 }, + asset_source_policy: "image2_asset", + collision_rule: "avoid wrapper title/subtitle and chart panels" + }, + { + name: "header-right-audio-icon", + anchor: "header safe area", + bbox_ratio: { x: 0.86, y: 0.07, w: 0.11, h: 0.08 }, + asset_source_policy: "image2_asset", + collision_rule: "avoid wrapper title/subtitle and chart panels" + } + ] + })); + + const defs = svg.append("defs"); + + const leftBase = colorResolver.field(opinionGroups[0], 0, { fallbackKey: "primary" }).value || + colorResolver.other("primary", { fallback: "#6236c8" }).value || "#6236c8"; + const rightBase = "#ef4b98"; + const textColor = colorResolver.text({ fallback: "#25304f" }).value || "#25304f"; + const mutedText = "#5a6380"; + const panelStroke = "#eee8fb"; + const trackColor = "#eeeaf6"; + + const leftGradient = defs.append("linearGradient") + .attr("id", `${uid}-left-bar-gradient`) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + leftGradient.append("stop").attr("offset", "0%").attr("stop-color", "#4d2bb2"); + leftGradient.append("stop").attr("offset", "100%").attr("stop-color", leftBase); + + const rightGradient = defs.append("linearGradient") + .attr("id", `${uid}-right-bar-gradient`) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + rightGradient.append("stop").attr("offset", "0%").attr("stop-color", "#f75a9d"); + rightGradient.append("stop").attr("offset", "100%").attr("stop-color", "#e93e8e"); + + const yearGradient = defs.append("linearGradient") + .attr("id", `${uid}-year-card-gradient`) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "100%"); + yearGradient.append("stop").attr("offset", "0%").attr("stop-color", "#8c4fe2"); + yearGradient.append("stop").attr("offset", "100%").attr("stop-color", "#382188"); + + const softShadow = defs.append("filter") + .attr("id", `${uid}-panel-shadow`) + .attr("x", "-8%") + .attr("y", "-18%") + .attr("width", "116%") + .attr("height", "136%"); + softShadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 3) + .attr("stdDeviation", 5) + .attr("flood-color", "#4b2b7f") + .attr("flood-opacity", 0.11); + + const root = svg.append("g") + .attr("class", "horizontal-diverging-card-layout") + .attr("data-chart-element", "chart-owned-layout") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + const chartW = Math.min(width - 24, 575); + const chartX = 0; + const legendY = 4; + const legendW = Math.min(290, chartW * 0.62); + const legendH = 30; + const legendX = chartX + chartW / 2 - legendW / 2; + const stackY = 42; + const stackH = Math.min(height - stackY - 10, 535); + const panelGap = topics.length > 7 ? 5 : 7; + const panelH = Math.max(42, (stackH - panelGap * Math.max(0, topics.length - 1)) / Math.max(1, topics.length)); + const panelW = chartW; + const yearCardW = Math.max(62, Math.min(74, panelW * 0.14)); + const panelRadius = 11; + + const labelX = chartX + yearCardW + 48; + const leftStartX = chartX + yearCardW + 60; + const dividerX = chartX + panelW * 0.59; + const centerGap = 12; + const leftZeroX = dividerX - centerGap; + const rightZeroX = dividerX + centerGap; + const rightEndX = chartX + panelW - 48; + const leftMaxW = Math.max(50, leftZeroX - leftStartX); + const rightMaxW = Math.max(50, rightEndX - rightZeroX); + + const xScaleLeft = d3.scaleLinear().domain([0, scaleMax]).range([0, leftMaxW]); + const xScaleRight = d3.scaleLinear().domain([0, scaleMax]).range([0, rightMaxW]); + + function formatValue(value) { + return `${chartUtils.format.autoText(value)}${valueUnit}`; + } + + function trimLabel(text, maxChars) { + const value = String(text); + if (value.length <= maxChars) return value; + return `${value.slice(0, Math.max(1, maxChars - 1))}...`; + } + + function leftRoundedRectPath(x, y, w, h, r) { + const radius = Math.min(r, w / 2, h / 2); + return [ + `M ${x + radius} ${y}`, + `H ${x + w}`, + `V ${y + h}`, + `H ${x + radius}`, + `Q ${x} ${y + h} ${x} ${y + h - radius}`, + `V ${y + radius}`, + `Q ${x} ${y} ${x + radius} ${y}`, + "Z" + ].join(" "); + } + + root.append("rect") + .attr("x", legendX) + .attr("y", legendY) + .attr("width", legendW) + .attr("height", legendH) + .attr("rx", 7) + .attr("fill", "#ffffff") + .attr("stroke", panelStroke) + .attr("filter", `url(#${uid}-panel-shadow)`) + .attr("data-chart-element", "legend-background"); + + const legend = root.append("g") + .attr("class", "legend") + .attr("data-chart-element", "platform-legend") + .attr("transform", `translate(${legendX + 18}, ${legendY + legendH / 2})`); + + [ + { label: opinionGroups[0], color: leftBase }, + { label: opinionGroups[1], color: rightBase } + ].forEach((item, index) => { + const itemX = index === 0 ? 0 : legendW * 0.55; + legend.append("circle") + .attr("cx", itemX) + .attr("cy", 0) + .attr("r", 6) + .attr("fill", item.color); + legend.append("text") + .attr("x", itemX + 12) + .attr("y", 0) + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", "13px") + .style("font-weight", 600) + .style("fill", "#232846") + .text(trimLabel(item.label, 14)); + }); + + topics.forEach((topic, topicIndex) => { + const panelY = stackY + topicIndex * (panelH + panelGap); + const rowCount = supporterGroups.length; + const densePanel = panelH < 54 || (topics.length * supporterGroups.length) > 42; + const headerY = panelY + (densePanel ? Math.max(8, panelH * 0.18) : Math.max(14, panelH * 0.2)); + const rowsTop = panelY + (densePanel ? Math.max(12, panelH * 0.27) : Math.max(27, panelH * 0.38)); + const rowsBottomPad = densePanel ? 4 : 8; + const rowStep = (panelH - (rowsTop - panelY) - rowsBottomPad) / Math.max(1, rowCount); + const barH = densePanel ? Math.max(2.6, Math.min(4.2, rowStep * 0.50)) : Math.max(5.4, Math.min(8.2, rowStep * 0.62)); + const barRadius = Math.min(2.2, barH * 0.35); + const fontSize = densePanel ? Math.max(5.2, Math.min(6.2, rowStep * 0.72)) : Math.max(7.8, Math.min(9.6, rowStep * 0.74)); + const showValueLabels = !densePanel && rowStep >= 7.4; + + const panel = root.append("g") + .attr("class", "year-panel") + .attr("data-chart-element", "year-panel") + .attr("data-year", topic) + .attr("transform", `translate(${chartX}, ${panelY})`); + + panel.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", panelW) + .attr("height", panelH) + .attr("rx", panelRadius) + .attr("fill", "#ffffff") + .attr("stroke", panelStroke) + .attr("stroke-width", 1) + .attr("filter", `url(#${uid}-panel-shadow)`); + + panel.append("path") + .attr("d", leftRoundedRectPath(0, 0, yearCardW, panelH, panelRadius)) + .attr("fill", `url(#${uid}-year-card-gradient)`) + .attr("data-chart-element", "year-card"); + + const slotW = Math.min(34, yearCardW * 0.46); + const slotH = Math.min(28, panelH * 0.30); + const slotX = yearCardW / 2 - slotW / 2; + const slotY = Math.max(7, panelH * 0.17 - slotH / 2); + const yearSlot = panel.append("g") + .attr("class", "year-card-temporal-slot") + .attr("data-asset-slot", "year-card-temporal-icon") + .attr("data-asset-anchor", `year-card:${topic}`) + .attr("data-asset-bbox", `${slotX},${slotY},${slotW},${slotH}`) + .attr("data-asset-collision", "contained-in-year-card;avoid-year-label") + .attr("data-asset-source-policy", "neutral_placeholder") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + + yearSlot.append("rect") + .attr("x", slotX) + .attr("y", slotY) + .attr("width", slotW) + .attr("height", slotH) + .attr("rx", 5) + .attr("fill", "rgba(255,255,255,0.12)") + .attr("stroke", "rgba(255,255,255,0.88)") + .attr("stroke-width", 1.8) + .attr("opacity", 0.9); + + yearSlot.append("rect") + .attr("x", slotX + slotW * 0.16) + .attr("y", slotY + slotH * 0.28) + .attr("width", slotW * 0.68) + .attr("height", slotH * 0.46) + .attr("rx", 2.5) + .attr("fill", "none") + .attr("stroke", "rgba(255,255,255,0.58)") + .attr("stroke-width", 1.1) + .attr("stroke-dasharray", "3 2") + .attr("opacity", 0.96); + + panel.append("text") + .attr("x", yearCardW / 2) + .attr("y", panelH * 0.68) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.max(17, Math.min(23, panelH * 0.28))}px`) + .style("font-weight", 800) + .style("fill", "#ffffff") + .text(topic); + + panel.append("text") + .attr("x", leftStartX + (leftZeroX - leftStartX) / 2) + .attr("y", headerY - panelY) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${densePanel ? Math.max(5.6, Math.min(7, panelH * 0.14)) : Math.max(9, Math.min(12, panelH * 0.16))}px`) + .style("font-weight", 800) + .style("letter-spacing", "0") + .style("fill", leftBase) + .text(trimLabel(opinionGroups[0], 14)); + + panel.append("text") + .attr("x", rightZeroX + (rightEndX - rightZeroX) / 2) + .attr("y", headerY - panelY) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${densePanel ? Math.max(5.6, Math.min(7, panelH * 0.14)) : Math.max(9, Math.min(12, panelH * 0.16))}px`) + .style("font-weight", 800) + .style("letter-spacing", "0") + .style("fill", rightBase) + .text(trimLabel(opinionGroups[1], 14)); + + panel.append("line") + .attr("x1", dividerX) + .attr("y1", Math.max(22, panelH * 0.3)) + .attr("x2", dividerX) + .attr("y2", panelH - 10) + .attr("stroke", "#d8d0e9") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 3") + .attr("data-chart-element", "center-divider"); + + supporterGroups.forEach((supporter, supporterIndex) => { + const rowCenterY = rowsTop - panelY + supporterIndex * rowStep + rowStep / 2; + const leftKey = `${topic}|||${supporter}|||${opinionGroups[0]}`; + const rightKey = `${topic}|||${supporter}|||${opinionGroups[1]}`; + const leftValue = valuesByKey.has(leftKey) ? valuesByKey.get(leftKey) : null; + const rightValue = valuesByKey.has(rightKey) ? valuesByKey.get(rightKey) : null; + + panel.append("line") + .attr("x1", leftStartX) + .attr("x2", leftZeroX) + .attr("y1", rowCenterY) + .attr("y2", rowCenterY) + .attr("stroke", trackColor) + .attr("stroke-width", Math.max(1, barH * 0.64)) + .attr("stroke-linecap", "round") + .attr("opacity", 0.72); + + panel.append("line") + .attr("x1", rightZeroX) + .attr("x2", rightEndX) + .attr("y1", rowCenterY) + .attr("y2", rowCenterY) + .attr("stroke", trackColor) + .attr("stroke-width", Math.max(1, barH * 0.64)) + .attr("stroke-linecap", "round") + .attr("opacity", 0.72); + + panel.append("text") + .attr("x", labelX) + .attr("y", rowCenterY) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${fontSize}px`) + .style("font-weight", 500) + .style("fill", textColor) + .text(trimLabel(supporter, 10)); + + if (leftValue != null && Number.isFinite(leftValue)) { + const barW = xScaleLeft(leftValue); + const x = leftZeroX - barW; + panel.append("rect") + .attr("x", x) + .attr("y", rowCenterY - barH / 2) + .attr("width", Math.max(0.5, barW)) + .attr("height", barH) + .attr("rx", barRadius) + .attr("ry", barRadius) + .attr("fill", `url(#${uid}-left-bar-gradient)`) + .attr("data-chart-element", "bar") + .attr("data-year", topic) + .attr("data-platform", opinionGroups[0]) + .attr("data-age-group", supporter) + .attr("data-value", leftValue); + + if (showValueLabels) { + const label = formatValue(leftValue); + const inside = barW > label.length * fontSize * 0.52 + 8; + panel.append("text") + .attr("x", inside ? x + 5 : Math.max(yearCardW + 5, x - 4)) + .attr("y", rowCenterY) + .attr("text-anchor", inside ? "start" : "end") + .attr("dominant-baseline", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(5.8, fontSize - 0.8)}px`) + .style("font-weight", 700) + .style("fill", inside ? "#ffffff" : leftBase) + .text(label); + } + } + + if (rightValue != null && Number.isFinite(rightValue)) { + const barW = xScaleRight(rightValue); + panel.append("rect") + .attr("x", rightZeroX) + .attr("y", rowCenterY - barH / 2) + .attr("width", Math.max(0.5, barW)) + .attr("height", barH) + .attr("rx", barRadius) + .attr("ry", barRadius) + .attr("fill", `url(#${uid}-right-bar-gradient)`) + .attr("data-chart-element", "bar") + .attr("data-year", topic) + .attr("data-platform", opinionGroups[1]) + .attr("data-age-group", supporter) + .attr("data-value", rightValue); + + if (showValueLabels) { + const label = formatValue(rightValue); + const outsideX = Math.min(chartX + panelW - 8, rightZeroX + barW + 5); + const inside = outsideX >= chartX + panelW - 10 && barW > label.length * fontSize * 0.52 + 8; + panel.append("text") + .attr("x", inside ? rightZeroX + barW - 5 : outsideX) + .attr("y", rowCenterY) + .attr("text-anchor", inside ? "end" : "start") + .attr("dominant-baseline", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(5.8, fontSize - 0.8)}px`) + .style("font-weight", 700) + .style("fill", inside ? "#ffffff" : rightBase) + .text(label); + } + } + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_11.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_11.js new file mode 100644 index 0000000000000000000000000000000000000000..87c57a2ef3f22555f03dbac74a33176ababd13f8 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_11.js @@ -0,0 +1,444 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_11", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "none", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// Reference-local card layout for selected GPT image-2 sample_00 variant_03. +function makeChart(containerSelector, data) { + const jsonData = data; + const rawData = Array.isArray(jsonData.data) ? jsonData.data : (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const width = Math.max(+variables.width || 714, 1180); + const height = Math.min(Math.max(+variables.height || 520, 500), 540); + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + const dimensionUnit = dimensionChannel.unit && dimensionChannel.unit !== "none" ? dimensionChannel.unit : ""; + const valueUnit = valueChannel.unit && valueChannel.unit !== "none" ? valueChannel.unit : ""; + const groupUnit = groupChannel.unit && groupChannel.unit !== "none" ? groupChannel.unit : ""; + + const groups = [...new Set(rawData.map(d => d[groupField]))].slice(0, 2); + const dimensions = [...new Set(rawData.map(d => d[dimensionField]))].sort((a, b) => { + const na = +a; + const nb = +b; + if (Number.isFinite(na) && Number.isFinite(nb)) return na - nb; + return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: "base" }); + }); + const leftGroup = groups[0]; + const rightGroup = groups[1]; + const complete = groups.length === 2 && dimensions.every(dimension => + rawData.some(d => d[dimensionField] === dimension && d[groupField] === leftGroup) && + rawData.some(d => d[dimensionField] === dimension && d[groupField] === rightGroup) + ); + + if (!complete) { + d3.select(containerSelector) + .append("div") + .style("color", "#b87312") + .style("text-align", "center") + .style("padding", "20px") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", typography.label.font_size || "12px") + .text("Missing paired group data for horizontal diverging bars."); + return; + } + + const values = rawData.map(d => Math.max(0, +d[valueField] || 0)); + const maxValue = d3.max(values) || 1; + const titleText = [ + jsonData.title, + jsonData.titles && jsonData.titles.main_title, + jsonData.title_text, + jsonData.meta && jsonData.meta.title + ].filter(Boolean).join(" "); + + const leftColor = "#1762d4"; + const leftLight = "#eaf2ff"; + const rightColor = "#d79519"; + const rightLight = "#fff4dc"; + const textColor = colorResolver.text({ fallback: "#12275c" }).value; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink") + .attr("data-chart-variation", "horizontal_diverging_bar_chart_11") + .attr("data-reference-layout", "sample_00_gpt_image_2_03"); + + const defs = svg.append("defs"); + const filter = defs.append("filter") + .attr("id", "hdbar11-card-shadow") + .attr("x", "-8%") + .attr("y", "-10%") + .attr("width", "116%") + .attr("height", "124%"); + filter.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 6) + .attr("stdDeviation", 8) + .attr("flood-color", "#6780ad") + .attr("flood-opacity", 0.18); + + const makeGradient = (id, stops) => { + const grad = defs.append("linearGradient").attr("id", id).attr("x1", "0%").attr("x2", "100%").attr("y1", "0%").attr("y2", "0%"); + stops.forEach(stop => grad.append("stop").attr("offset", stop.offset).attr("stop-color", stop.color).attr("stop-opacity", stop.opacity || 1)); + }; + makeGradient("hdbar11-blue-gradient", [ + { offset: "0%", color: "#a8c8ff" }, + { offset: "100%", color: leftColor } + ]); + makeGradient("hdbar11-gold-gradient", [ + { offset: "0%", color: "#f4c257" }, + { offset: "100%", color: "#d68d12" } + ]); + + const makeHatch = (id, baseFill) => { + const pattern = defs.append("pattern") + .attr("id", id) + .attr("patternUnits", "userSpaceOnUse") + .attr("width", 7) + .attr("height", 7) + .attr("patternTransform", "rotate(45)"); + pattern.append("rect").attr("width", 7).attr("height", 7).attr("fill", baseFill); + pattern.append("line") + .attr("x1", 0) + .attr("y1", 0) + .attr("x2", 0) + .attr("y2", 7) + .attr("stroke", "#ffffff") + .attr("stroke-width", 1.25) + .attr("opacity", 0.35); + }; + makeHatch("hdbar11-blue-hatch", "url(#hdbar11-blue-gradient)"); + makeHatch("hdbar11-gold-hatch", "url(#hdbar11-gold-gradient)"); + + const cardX = Math.max(6, width * 0.018); + const cardY = Math.max(6, height * 0.02); + const cardW = width - cardX * 2; + const cardH = height - cardY * 2; + const padX = Math.max(28, Math.min(48, width * 0.04)); + const headerH = Math.max(58, Math.min(76, cardH * 0.16)); + const rowTop = cardY + headerH + 18; + const rowBottom = cardY + cardH - 18; + const rowAreaH = Math.max(100, rowBottom - rowTop); + const rowStep = rowAreaH / dimensions.length; + const barH = Math.max(10, Math.min(22, rowStep * 0.42)); + const chipR = Math.max(11, Math.min(18, rowStep * 0.34)); + const centerX = width / 2; + const maxDimensionChars = d3.max(dimensions, d => String(dimensionUnit ? `${d}${dimensionUnit}` : d).length) || 1; + const compactCenterLabels = maxDimensionChars <= 4; + const centerGap = compactCenterLabels + ? chipR * 2 + Math.max(28, width * 0.034) + : Math.min(width * 0.22, Math.max(chipR * 2 + 44, maxDimensionChars * 6.6 + 30)); + const centerChipW = compactCenterLabels ? chipR * 2 : Math.max(chipR * 2 + 20, centerGap - 22); + const labelW = Math.max(88, Math.min(118, width * 0.1)); + const leftTrackX = cardX + padX + labelW + 10; + const leftTrackEnd = centerX - centerGap / 2; + const rightTrackX = centerX + centerGap / 2; + const rightLabelW = labelW; + const rightTrackEnd = cardX + cardW - padX - rightLabelW - 10; + const trackW = Math.max(36, Math.min(leftTrackEnd - leftTrackX, rightTrackEnd - rightTrackX)); + const leftValueX = Math.max(cardX + padX + labelW - 8, leftTrackX - 20); + const rightValueX = Math.min(cardX + cardW - padX - rightLabelW + 8, rightTrackX + trackW + 20); + const labelFont = Math.max(11, Math.min(16, rowStep * 0.29)); + const valueFont = Math.max(11, Math.min(17, rowStep * 0.34)); + + svg.append("rect") + .attr("class", "hdbar11-chart-card") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardW) + .attr("height", cardH) + .attr("rx", 14) + .attr("fill", "#ffffff") + .attr("stroke", "#e3e9f4") + .attr("stroke-width", 1) + .attr("filter", "url(#hdbar11-card-shadow)"); + + const headerY = cardY + Math.max(29, headerH * 0.58); + const leftHeaderX = cardX + padX + Math.max(118, Math.min(150, cardW * 0.2)); + const rightHeaderX = cardX + cardW - padX - Math.max(118, Math.min(150, cardW * 0.2)); + + const groupLabel = group => { + let label = `${group}${groupUnit || ""}`.trim(); + if (/developer/i.test(titleText) && !/developer/i.test(label)) label = `${label} Developers`; + return label.toUpperCase(); + }; + + const addHeaderSlot = (x, y, side, color) => { + const slot = svg.append("g") + .attr("class", `hdbar11-header-icon-slot hdbar11-${side}-icon-slot`) + .attr("data-asset-slot", `${side}-group-icon`) + .attr("data-slot-policy", "neutral_placeholder") + .attr("data-slot-anchor", `${side}-group-header`) + .attr("data-slot-bbox", `${Math.round(x - 14)},${Math.round(y - 14)},28,28`) + .attr("data-slot-mask", "circle") + .attr("data-slot-collision", "inside-chart-card-header-row") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle") + .attr("cx", x) + .attr("cy", y) + .attr("r", 13) + .attr("fill", "#ffffff") + .attr("stroke", color) + .attr("stroke-width", 2); + slot.append("circle") + .attr("cx", x) + .attr("cy", y) + .attr("r", 3.2) + .attr("fill", color) + .attr("opacity", 0.52); + }; + + addHeaderSlot(leftHeaderX - Math.max(84, Math.min(104, cardW * 0.14)), headerY - 1, "left", leftColor); + addHeaderSlot(rightHeaderX - Math.max(84, Math.min(104, cardW * 0.14)), headerY - 1, "right", rightColor); + + svg.append("text") + .attr("x", leftHeaderX + 12) + .attr("y", headerY + 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", `${Math.max(11, Math.min(14, width * 0.018))}px`) + .style("font-weight", 800) + .style("fill", leftColor) + .text(groupLabel(leftGroup)); + + svg.append("text") + .attr("x", rightHeaderX + 16) + .attr("y", headerY + 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", `${Math.max(11, Math.min(14, width * 0.018))}px`) + .style("font-weight", 800) + .style("fill", rightColor) + .text(groupLabel(rightGroup)); + + svg.append("text") + .attr("x", centerX) + .attr("y", headerY + 5) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", `${Math.max(10, Math.min(13, width * 0.017))}px`) + .style("font-weight", 700) + .style("letter-spacing", "0") + .style("fill", "#202848") + .attr("textLength", String(dimensionField || "Category").length > 10 ? Math.min(centerGap - 12, 100) : null) + .attr("lengthAdjust", String(dimensionField || "Category").length > 10 ? "spacingAndGlyphs" : null) + .text(String(dimensionField || "Category").toUpperCase()); + + svg.append("line") + .attr("x1", cardX + padX) + .attr("x2", cardX + cardW - padX) + .attr("y1", cardY + headerH) + .attr("y2", cardY + headerH) + .attr("stroke", "#e2e7f0") + .attr("stroke-width", 1); + + const leftByDimension = new Map(rawData.filter(d => d[groupField] === leftGroup).map(d => [d[dimensionField], d])); + const rightByDimension = new Map(rawData.filter(d => d[groupField] === rightGroup).map(d => [d[dimensionField], d])); + const leftMaxValue = d3.max([...leftByDimension.values()], d => +d[valueField] || 0) || maxValue; + const rightMaxValue = d3.max([...rightByDimension.values()], d => +d[valueField] || 0) || maxValue; + + const formatDimension = value => dimensionUnit ? `${value}${dimensionUnit}` : `${value}`; + const formatValueParts = value => { + const numeric = +value || 0; + if (/usd|\$|dollar/i.test(valueUnit) && Math.abs(numeric) >= 1000) { + return { number: `${chartUtils.format.autoText(numeric / 1000)}K`, unit: "USD" }; + } + const formatted = chartUtils.format.autoText(numeric); + return { number: formatted, unit: valueUnit }; + }; + + const addValueLabel = (x, y, value, color, anchor) => { + const parts = formatValueParts(value); + const text = svg.append("text") + .attr("class", "hdbar11-value-label") + .attr("x", x) + .attr("y", y + 1) + .attr("dy", "0.35em") + .attr("text-anchor", anchor) + .style("font-family", typography.annotation.font_family || "Arial") + .style("font-weight", 800) + .style("font-size", `${valueFont}px`) + .style("fill", color) + .attr("data-value", value) + .attr("data-label-anchor", "bar-outer-endpoint") + .attr("data-coordinate-rule", "attached-row-centerline"); + text.append("tspan").text(parts.number); + if (parts.unit) { + text.append("tspan") + .style("font-size", `${Math.max(8, valueFont * 0.58)}px`) + .style("font-weight", 700) + .attr("dx", 3) + .text(parts.unit); + } + }; + + dimensions.forEach((dimension, index) => { + const rowCenterY = rowTop + index * rowStep + rowStep / 2; + const guideY = rowTop + index * rowStep; + const leftDatum = leftByDimension.get(dimension); + const rightDatum = rightByDimension.get(dimension); + const leftValue = +leftDatum[valueField] || 0; + const rightValue = +rightDatum[valueField] || 0; + const leftBarW = Math.max(3, trackW * Math.min(1, 0.38 + 0.62 * Math.sqrt(Math.max(0, leftValue) / leftMaxValue))); + const rightBarW = Math.max(3, trackW * Math.min(1, 0.30 + 0.70 * Math.sqrt(Math.max(0, rightValue) / rightMaxValue))); + const leftBarX = leftTrackX; + const rightBarX = rightTrackX; + const barY = rowCenterY - barH / 2; + const radius = barH / 2; + + svg.append("line") + .attr("class", "hdbar11-row-guide") + .attr("x1", cardX + padX) + .attr("x2", cardX + cardW - padX) + .attr("y1", guideY) + .attr("y2", guideY) + .attr("stroke", "#e4eaf4") + .attr("stroke-width", 1) + .attr("stroke-dasharray", index % 2 === 0 ? "3 3" : null) + .attr("opacity", 0.86); + + svg.append("rect") + .attr("class", "hdbar11-left-track") + .attr("x", leftTrackX) + .attr("y", barY) + .attr("width", trackW) + .attr("height", barH) + .attr("rx", radius) + .attr("fill", leftLight); + svg.append("rect") + .attr("class", "hdbar11-right-track") + .attr("x", rightTrackX) + .attr("y", barY) + .attr("width", trackW) + .attr("height", barH) + .attr("rx", radius) + .attr("fill", rightLight); + + svg.append("rect") + .attr("class", "hdbar11-bar hdbar11-left-bar") + .attr("x", leftBarX) + .attr("y", barY) + .attr("width", leftBarW) + .attr("height", barH) + .attr("rx", radius) + .attr("fill", "url(#hdbar11-blue-hatch)") + .attr("data-category", dimension) + .attr("data-group", leftGroup) + .attr("data-value", leftValue) + .attr("data-endpoint-shape", "rounded-pill-like") + .attr("data-coordinate-rule", "row-centerline-left-of-center-chip"); + svg.append("rect") + .attr("class", "hdbar11-bar hdbar11-right-bar") + .attr("x", rightBarX) + .attr("y", barY) + .attr("width", rightBarW) + .attr("height", barH) + .attr("rx", radius) + .attr("fill", "url(#hdbar11-gold-hatch)") + .attr("data-category", dimension) + .attr("data-group", rightGroup) + .attr("data-value", rightValue) + .attr("data-endpoint-shape", "rounded-pill-like") + .attr("data-coordinate-rule", "row-centerline-right-of-center-chip"); + + if (compactCenterLabels) { + svg.append("circle") + .attr("class", "hdbar11-center-chip") + .attr("cx", centerX) + .attr("cy", rowCenterY) + .attr("r", chipR) + .attr("fill", "#ffffff") + .attr("stroke", "#dbe3ef") + .attr("stroke-width", 1) + .attr("filter", "url(#hdbar11-card-shadow)") + .attr("data-coordinate-rule", "centerline-aligned") + .attr("data-category", dimension); + } else { + svg.append("rect") + .attr("class", "hdbar11-center-chip hdbar11-center-chip-pill") + .attr("x", centerX - centerChipW / 2) + .attr("y", rowCenterY - chipR) + .attr("width", centerChipW) + .attr("height", chipR * 2) + .attr("rx", chipR) + .attr("fill", "#ffffff") + .attr("stroke", "#dbe3ef") + .attr("stroke-width", 1) + .attr("filter", "url(#hdbar11-card-shadow)") + .attr("data-coordinate-rule", "centerline-aligned-pill") + .attr("data-category", dimension); + } + const formattedDimension = formatDimension(dimension); + const dimensionSafeWidth = centerChipW - 9; + const needsFit = formattedDimension.length * labelFont * 0.56 > dimensionSafeWidth; + svg.append("text") + .attr("class", "hdbar11-center-chip-label") + .attr("x", centerX) + .attr("y", rowCenterY + 1) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family || "Arial") + .style("font-size", `${labelFont}px`) + .style("font-weight", 800) + .style("fill", textColor) + .attr("textLength", needsFit ? dimensionSafeWidth : null) + .attr("lengthAdjust", needsFit ? "spacingAndGlyphs" : null) + .text(formattedDimension); + + addValueLabel(leftValueX, rowCenterY, leftValue, leftColor, "end"); + addValueLabel(rightValueX, rowCenterY, rightValue, rightColor, "start"); + }); + + svg.append("line") + .attr("class", "hdbar11-center-divider") + .attr("x1", centerX) + .attr("x2", centerX) + .attr("y1", rowTop - 4) + .attr("y2", rowBottom + 2) + .attr("stroke", "#d7deea") + .attr("stroke-width", 1.1) + .attr("stroke-dasharray", "2 6") + .attr("opacity", 0.8) + .lower(); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..98591c90953cd6b888364b2261b4c67596a3d8ed --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_diverging_bar_chart_12.js @@ -0,0 +1,596 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Diverging Bar Chart", + "chart_name": "horizontal_diverging_bar_chart_12", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data; + const chartData = (jsonData.data && jsonData.data.data) || []; + const variables = jsonData.variables || {}; + const columns = (jsonData.data && jsonData.data.columns) || []; + const colorResolver = chartUtils.color.resolver(jsonData); + + d3.select(containerSelector).html(""); + + const width = variables.width || 1024; + const height = variables.height || 1536; + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + defs.append("linearGradient") + .attr("id", "hd12-bg") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "0%") + .attr("y2", "100%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#fbfff8"); + g.append("stop").attr("offset", "62%").attr("stop-color", "#ffffff"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#f4f7ef"); + }); + defs.append("linearGradient") + .attr("id", "hd12-left-grad") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#7fbd2f"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#2d7f20"); + }); + defs.append("linearGradient") + .attr("id", "hd12-right-grad") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%") + .call(g => { + g.append("stop").attr("offset", "0%").attr("stop-color", "#0f74d7"); + g.append("stop").attr("offset", "100%").attr("stop-color", "#074aa9"); + }); + const shadow = defs.append("filter") + .attr("id", "hd12-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "140%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 8) + .attr("stdDeviation", 10) + .attr("flood-color", "#24420e") + .attr("flood-opacity", 0.11); + + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("fill", "url(#hd12-bg)"); + + const channel = (name, fallbackIndex) => { + try { + const resolved = chartUtils.schema.channel(jsonData, name); + if (resolved && resolved.key) return resolved; + } catch (e) {} + const col = columns[fallbackIndex] || {}; + return { key: col.name, unit: col.unit || "" }; + }; + const dimensionChannel = channel("x", 0); + const valueChannel = channel("y", 1); + const groupChannel = channel("group", 2); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + const valueUnit = valueChannel.unit && valueChannel.unit !== "none" ? valueChannel.unit : ""; + + const groups = Array.from(new Set(chartData.map(d => d[groupField]))).slice(0, 2); + const leftGroup = groups[0] || "Group A"; + const rightGroup = groups[1] || "Group B"; + const dimensionsInInput = Array.from(new Set(chartData.map(d => d[dimensionField]))); + const temporalNames = ["year", "date", "month", "season", "semester", "quarter", "time"]; + const dimensionName = String(dimensionField || "").toLowerCase(); + const dimensionColumn = columns.find(c => c.name === dimensionField) || {}; + const isTemporal = temporalNames.some(token => dimensionName.includes(token)) || + String(dimensionColumn.data_type || "").toLowerCase().includes("temporal"); + const monthIndex = { + jan: 1, january: 1, feb: 2, february: 2, mar: 3, march: 3, apr: 4, april: 4, + may: 5, jun: 6, june: 6, jul: 7, july: 7, aug: 8, august: 8, sep: 9, + sept: 9, september: 9, oct: 10, october: 10, nov: 11, november: 11, + dec: 12, december: 12 + }; + const temporalKey = (value) => { + if (typeof value === "number") return value; + const raw = String(value || "").trim(); + const numeric = Number(raw.replace(/[^0-9.-]/g, "")); + if (!Number.isNaN(numeric) && raw.match(/[0-9]/)) return numeric; + return monthIndex[raw.toLowerCase()] || raw.toLowerCase(); + }; + const dimensions = isTemporal + ? dimensionsInInput.slice().sort((a, b) => d3.ascending(temporalKey(a), temporalKey(b))) + : dimensionsInInput.slice(); + + const rows = dimensions.map(dimension => { + const left = chartData.find(d => d[dimensionField] === dimension && d[groupField] === leftGroup); + const right = chartData.find(d => d[dimensionField] === dimension && d[groupField] === rightGroup); + return { + dimension, + left, + right, + leftValue: left ? Math.abs(+left[valueField]) || 0 : 0, + rightValue: right ? Math.abs(+right[valueField]) || 0 : 0 + }; + }); + const leftMax = d3.max(rows, d => d.leftValue) || 1; + const rightMax = d3.max(rows, d => d.rightValue) || 1; + + const getGroupColor = (group, index, fallback) => { + try { + return colorResolver.field(group, index, { fallbackKey: "primary" }).value || fallback; + } catch (e) { + return fallback; + } + }; + const leftColor = getGroupColor(leftGroup, 0, "#4e9a1d"); + const rightColor = getGroupColor(rightGroup, 1, "#0b63c7"); + const titleDark = "#082746"; + const greenDark = "#185d20"; + const mutedText = "#3f4a48"; + + const formatValue = (value) => { + if (!Number.isFinite(value)) return ""; + let text; + if (valueUnit === "$") { + const absValue = Math.abs(value); + if (absValue >= 1000000) { + text = `${(value / 1000000).toFixed(value % 1000000 === 0 ? 0 : 1)}M`; + } else if (absValue >= 1000) { + text = `${(value / 1000).toFixed(value % 1000 === 0 ? 0 : 1)}k`; + } else { + text = Number.isInteger(value) ? String(value) : value.toFixed(1).replace(/\.0$/, ""); + } + return `$${text}`; + } + if (valueUnit === "%") { + text = Math.abs(value % 1) > 0.001 ? value.toFixed(1) : value.toFixed(0); + return `${text}%`; + } + if (valueUnit.toLowerCase() === "ppm") { + text = value < 0.1 ? value.toFixed(3).replace(/0+$/, "").replace(/\.$/, "") : value.toFixed(2); + return `${text} ppm`; + } + if (Number.isInteger(value)) { + text = String(value); + } else if (Math.abs(value) < 1) { + text = value.toFixed(3).replace(/0+$/, "").replace(/\.$/, ""); + } else { + text = value.toFixed(1).replace(/\.0$/, ""); + } + return valueUnit ? `${text}${valueUnit}` : text; + }; + + const wrapWords = (text, maxChars, maxLines) => { + const words = String(text || "").split(/\s+/).filter(Boolean); + const lines = []; + let line = ""; + words.forEach(word => { + const next = line ? `${line} ${word}` : word; + if (next.length > maxChars && line) { + lines.push(line); + line = word; + } else { + line = next; + } + }); + if (line) lines.push(line); + if (maxLines && lines.length > maxLines) { + const clipped = lines.slice(0, maxLines); + clipped[maxLines - 1] = clipped[maxLines - 1].replace(/\s+\S+$/, ""); + return clipped; + } + return lines; + }; + + const titleSource = (jsonData.titles && jsonData.titles.main_title) || + (jsonData.metadata && jsonData.metadata.title) || "Diverging Comparison"; + const subtitleSource = (jsonData.titles && jsonData.titles.sub_title) || + (jsonData.metadata && jsonData.metadata.description) || ""; + const hasSplit = titleSource.toLowerCase().indexOf(" has "); + const kicker = hasSplit > 0 ? titleSource.slice(0, hasSplit) : wrapWords(titleSource, 28, 1)[0]; + const displayTitle = hasSplit > 0 ? titleSource.slice(hasSplit + 1) : titleSource.replace(kicker, "").trim() || titleSource; + const titleLines = wrapWords(displayTitle, 22, 2); + const subtitleLines = wrapWords(subtitleSource, 52, 4); + + const centerX = width / 2; + const page = svg.append("g").attr("class", "hd12-page"); + + page.append("rect") + .attr("x", 194) + .attr("y", 42) + .attr("width", 636) + .attr("height", 50) + .attr("rx", 25) + .attr("fill", "#0c6a35"); + page.append("text") + .attr("x", centerX) + .attr("y", 76) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 24) + .attr("font-weight", 800) + .attr("letter-spacing", 3) + .attr("fill", "#ffffff") + .text(String(kicker || "").toUpperCase()); + + const titleY = 142; + titleLines.forEach((line, i) => { + page.append("text") + .attr("x", 370) + .attr("y", titleY + i * 70) + .attr("text-anchor", "middle") + .attr("font-family", "Georgia, 'Times New Roman', serif") + .attr("font-size", titleLines.length > 1 ? 64 : 72) + .attr("font-weight", 800) + .attr("fill", i === 0 ? titleDark : greenDark) + .text(line); + }); + + const dividerY = titleY + titleLines.length * 70 + 22; + page.append("line").attr("x1", 282).attr("x2", 470).attr("y1", dividerY).attr("y2", dividerY) + .attr("stroke", "#6ea448").attr("stroke-width", 2); + page.append("line").attr("x1", 554).attr("x2", 742).attr("y1", dividerY).attr("y2", dividerY) + .attr("stroke", "#6ea448").attr("stroke-width", 2); + page.append("circle").attr("cx", centerX).attr("cy", dividerY).attr("r", 10).attr("fill", "#5d9d35").attr("opacity", 0.9); + + const subtitleY = dividerY + 52; + subtitleLines.forEach((line, i) => { + page.append("text") + .attr("x", centerX) + .attr("y", subtitleY + i * 36) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 23) + .attr("font-weight", 500) + .attr("fill", mutedText) + .text(line); + }); + + const headerSlot = page.append("g") + .attr("class", "reserved-asset-slot hd12-header-topic-art-slot") + .attr("data-asset-slot", "header-topic-art") + .attr("data-reserved-slot", "header_topic_art") + .attr("data-slot-policy", "image2_asset") + .attr("data-asset-source-policy", "image2-generated") + .attr("data-anchor", "upper-right-header-safe-area") + .attr("data-bbox", "842 266 126 126") + .attr("data-collision-rule", "stay-right-of-title-and-above-legend-table;shrink-or-hide-for-long-title") + .attr("data-mask", "rounded-rect") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("transform", "translate(842,266)"); + headerSlot.append("rect") + .attr("width", 126) + .attr("height", 126) + .attr("rx", 32) + .attr("fill", "#eaf5df") + .attr("stroke", "#9ac56d") + .attr("stroke-width", 2) + .attr("stroke-dasharray", "8 8") + .attr("opacity", 0.62); + headerSlot.append("circle").attr("cx", 45).attr("cy", 68).attr("r", 30).attr("fill", "#77aa43").attr("opacity", 0.18); + headerSlot.append("rect").attr("x", 78).attr("y", 42).attr("width", 30).attr("height", 56).attr("rx", 12).attr("fill", "#245f2b").attr("opacity", 0.12); + + const legendX = 104; + const legendY = 470; + const legendW = 816; + const legendH = 86; + page.append("rect") + .attr("x", legendX) + .attr("y", legendY) + .attr("width", legendW) + .attr("height", legendH) + .attr("rx", 24) + .attr("fill", "#ffffff") + .attr("stroke", "#d9e4d5") + .attr("stroke-width", 1.4) + .attr("filter", "url(#hd12-soft-shadow)"); + page.append("line") + .attr("x1", legendX + legendW / 2) + .attr("x2", legendX + legendW / 2) + .attr("y1", legendY + 18) + .attr("y2", legendY + legendH - 18) + .attr("stroke", "#c8d3d2") + .attr("stroke-width", 1.5); + + const drawLegendItem = (x, group, color, slotName) => { + const item = page.append("g").attr("transform", `translate(${x},${legendY + legendH / 2})`); + const slot = item.append("g") + .attr("class", "reserved-asset-slot hd12-legend-group-icon-slot") + .attr("data-asset-slot", "legend-group-icon") + .attr("data-reserved-slot", slotName) + .attr("data-slot-policy", "neutral_placeholder") + .attr("data-asset-source-policy", "neutral-placeholder") + .attr("data-anchor", `legend-${slotName}`) + .attr("data-bbox", `${x - 28} ${legendY + 17} 56 52`) + .attr("data-collision-rule", "stay-inside-legend-card-and-avoid-label") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true"); + slot.append("circle").attr("r", 25).attr("fill", color).attr("opacity", 0.18); + slot.append("circle").attr("r", 18).attr("fill", color).attr("opacity", 0.9); + item.append("text") + .attr("x", 46) + .attr("y", -4) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 22) + .attr("font-weight", 800) + .attr("fill", titleDark) + .text(group); + item.append("text") + .attr("x", 46) + .attr("y", 25) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 17) + .attr("fill", "#4a5552") + .text(valueUnit ? `(${valueUnit})` : "value"); + }; + drawLegendItem(148, leftGroup, leftColor, "legend_left_group_icon"); + drawLegendItem(562, rightGroup, rightColor, "legend_right_group_icon"); + + const tableX = 64; + const tableY = 625; + const tableW = 896; + const tableH = Math.min(850, height - tableY - 92); + const headerH = 60; + const rowH = (tableH - headerH) / Math.max(rows.length, 1); + const dimW = 270; + const leftW = 345; + const rightW = tableW - dimW - leftW; + const leftX = tableX + dimW; + const rightX = leftX + leftW; + + page.append("rect") + .attr("x", tableX) + .attr("y", tableY) + .attr("width", tableW) + .attr("height", tableH) + .attr("rx", 20) + .attr("fill", "#ffffff") + .attr("stroke", "#c8d8c8") + .attr("stroke-width", 1.4) + .attr("filter", "url(#hd12-soft-shadow)"); + page.append("clipPath") + .attr("id", "hd12-table-clip") + .append("rect") + .attr("x", tableX) + .attr("y", tableY) + .attr("width", tableW) + .attr("height", tableH) + .attr("rx", 20); + const table = page.append("g").attr("clip-path", "url(#hd12-table-clip)"); + table.append("rect").attr("x", tableX).attr("y", tableY).attr("width", dimW).attr("height", headerH).attr("fill", "#06482f"); + table.append("rect").attr("x", leftX).attr("y", tableY).attr("width", leftW).attr("height", headerH).attr("fill", "#0b5c30"); + table.append("rect").attr("x", rightX).attr("y", tableY).attr("width", rightW).attr("height", headerH).attr("fill", "#075f9f"); + + const headerText = (x, y, text, anchor) => { + table.append("text") + .attr("x", x) + .attr("y", y) + .attr("text-anchor", anchor || "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 19) + .attr("font-weight", 800) + .attr("letter-spacing", 1.2) + .attr("fill", "#ffffff") + .text(text); + }; + const groupHeaderText = (x, group) => { + const groupLines = wrapWords(String(group).toUpperCase(), 22, 2); + groupLines.forEach((line, index) => { + table.append("text") + .attr("x", x) + .attr("y", tableY + 25 + index * 19) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 17) + .attr("font-weight", 800) + .attr("letter-spacing", 0.8) + .attr("fill", "#ffffff") + .text(line); + }); + if (valueUnit) { + table.append("text") + .attr("x", x) + .attr("y", tableY + 52) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 14) + .attr("font-weight", 700) + .attr("fill", "#dbeee0") + .text(`(${valueUnit})`); + } + }; + headerText(tableX + dimW / 2, tableY + 38, String(dimensionField || "State").toUpperCase()); + groupHeaderText(leftX + leftW / 2, leftGroup); + groupHeaderText(rightX + rightW / 2, rightGroup); + + [leftX, rightX].forEach(x => { + table.append("line") + .attr("x1", x) + .attr("x2", x) + .attr("y1", tableY) + .attr("y2", tableY + tableH) + .attr("stroke", "#d9e2da") + .attr("stroke-width", 1.2); + }); + + const barH = Math.max(16, Math.min(28, rowH * 0.34)); + const leftBarX = leftX + 26; + const leftBarMaxW = leftW - 165; + const rightBarX = rightX + 25; + const rightBarMaxW = rightW - 220; + const labelFont = rowH < 58 ? 18 : 22; + const valueFont = rowH < 58 ? 16 : 21; + + rows.forEach((row, i) => { + const rowY = tableY + headerH + i * rowH; + const rowCenter = rowY + rowH / 2; + table.append("rect") + .attr("x", tableX) + .attr("y", rowY) + .attr("width", tableW) + .attr("height", rowH) + .attr("fill", i % 2 === 0 ? "#fbfdf8" : "#ffffff"); + table.append("line") + .attr("x1", tableX) + .attr("x2", tableX + tableW) + .attr("y1", rowY) + .attr("y2", rowY) + .attr("stroke", "#dfe7db") + .attr("stroke-width", 1); + + const slot = table.append("g") + .attr("class", "reserved-asset-slot hd12-row-topic-icon-slot") + .attr("data-asset-slot", "row-topic-icon") + .attr("data-reserved-slot", `row_topic_icon_${i + 1}`) + .attr("data-slot-policy", "image2_asset") + .attr("data-asset-source-policy", "image2-generated") + .attr("data-anchor", `row-${i + 1}-centerline`) + .attr("data-bbox", `${tableX + 30} ${rowCenter - 27} 54 54`) + .attr("data-collision-rule", "stay-inside-dimension-column-and-avoid-label-text") + .attr("data-mask", "circle") + .attr("data-no-embedded-raster", "true") + .attr("data-no-copied-reference-art", "true") + .attr("transform", `translate(${tableX + 57},${rowCenter})`); + slot.append("circle").attr("r", 27).attr("fill", i % 2 === 0 ? "#e3f2cd" : "#e5f4f8"); + slot.append("circle").attr("r", 16).attr("fill", i % 2 === 0 ? "#7ab546" : "#5ba4bd").attr("opacity", 0.18); + + const dimLabel = String(row.dimension); + const dimLines = wrapWords(dimLabel, rowH < 58 ? 14 : 16, 2); + dimLines.forEach((line, lineIndex) => { + table.append("text") + .attr("x", tableX + 104) + .attr("y", rowCenter + (lineIndex - (dimLines.length - 1) / 2) * (labelFont + 2) + 7) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", labelFont) + .attr("font-weight", 800) + .attr("fill", titleDark) + .text(line); + }); + + const leftWValue = Math.max(10, (row.leftValue / leftMax) * leftBarMaxW); + const rightWValue = Math.max(10, (row.rightValue / rightMax) * rightBarMaxW); + const leftY = rowCenter - barH / 2; + const rx = Math.min(12, barH / 2); + + table.append("rect") + .attr("x", leftBarX) + .attr("y", leftY) + .attr("width", leftWValue) + .attr("height", barH) + .attr("rx", rx) + .attr("ry", rx) + .attr("fill", "url(#hd12-left-grad)"); + table.append("text") + .attr("x", Math.min(leftBarX + leftWValue + 16, leftX + leftW - 120)) + .attr("y", rowCenter + 7) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", valueFont) + .attr("font-weight", 800) + .attr("fill", "#2c7a13") + .text(formatValue(row.leftValue)); + + table.append("rect") + .attr("x", rightBarX) + .attr("y", leftY) + .attr("width", rightWValue) + .attr("height", barH) + .attr("rx", rx) + .attr("ry", rx) + .attr("fill", "url(#hd12-right-grad)"); + table.append("text") + .attr("x", Math.min(rightBarX + rightWValue + 18, tableX + tableW - 155)) + .attr("y", rowCenter + 7) + .attr("font-family", "Arial, sans-serif") + .attr("font-size", valueFont) + .attr("font-weight", 800) + .attr("fill", "#075fbd") + .text(formatValue(row.rightValue)); + + if (row.leftValue === leftMax || row.rightValue === rightMax) { + const isLeft = row.leftValue === leftMax; + const badgeX = isLeft ? leftX + leftW - 8 : tableX + tableW - 34; + const badgeColor = isLeft ? "#0d7140" : "#0a67c7"; + const badge = table.append("g") + .attr("class", "hd12-max-value-badge") + .attr("data-annotation", "max-value") + .attr("data-group", isLeft ? leftGroup : rightGroup) + .attr("data-dimension", row.dimension) + .attr("data-anchor", "row-centerline-value-end") + .attr("data-collision-rule", "clamp-inside-table-edge-and-avoid-value-label") + .attr("transform", `translate(${badgeX},${rowCenter})`); + badge.append("rect") + .attr("x", -14) + .attr("y", -14) + .attr("width", 28) + .attr("height", 28) + .attr("rx", 6) + .attr("fill", badgeColor); + badge.append("text") + .attr("x", 0) + .attr("y", 7) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 18) + .attr("font-weight", 900) + .attr("fill", "#ffffff") + .attr("data-chart-native-marker", "max") + .text("★"); + } + }); + + table.append("line") + .attr("x1", tableX) + .attr("x2", tableX + tableW) + .attr("y1", tableY + tableH) + .attr("y2", tableY + tableH) + .attr("stroke", "#c8d8c8") + .attr("stroke-width", 1.4); + + page.append("text") + .attr("x", centerX) + .attr("y", height - 42) + .attr("text-anchor", "middle") + .attr("font-family", "Arial, sans-serif") + .attr("font-size", 14) + .attr("fill", "#8b968d") + .attr("data-ignored-bottom-wrapper", "takeaway-source-footer-omitted") + .text(""); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..b6655469f6107db5e1aac2562f73d5d766ca28ec --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_01.js @@ -0,0 +1,571 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "horizontal dot bar chart", + "chart_name": "horizontal_dot_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical", "temporal"], ["numerical"]], + "required_fields_range": [[2, 16], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const chartData = (jsonData.data && jsonData.data.data) || []; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const sourceColors = jsonData.colors || {}; + const colorOther = sourceColors.other || {}; + const colorField = sourceColors.field || {}; + + d3.select(containerSelector).html(""); + + const rowCount = Math.max(chartData.length, 1); + const requestedWidth = Number(variables.width) || 800; + const width = Math.max(requestedWidth, rowCount > 8 ? 1420 : 1180); + const requestedHeight = Number(variables.height) || 600; + const baseHeight = Math.max(requestedHeight, rowCount > 14 ? 610 : 560); + const height = Math.max(baseHeight, rowCount * 36 + 120); + + const labelTypography = typography.label || {}; + const valueTypography = typography.annotation || labelTypography; + const labelFamily = labelTypography.font_family || "Arial"; + const labelWeight = labelTypography.font_weight || "normal"; + const valueFamily = valueTypography.font_family || "Arial"; + const valueWeight = valueTypography.font_weight || "normal"; + const baseLabelSize = parseFloat(labelTypography.font_size) || 12; + const baseValueSize = parseFloat(valueTypography.font_size) || 12; + const textColor = sourceColors.text_color || "#0f1b36"; + const primaryColor = colorOther.primary || colorField.y || "#e5a300"; + const amber = d3.interpolateRgb("#f5b20a", primaryColor)(0.22); + const amberDark = "#cf8d00"; + const amberPale = "#fff4d5"; + const navy = "#0b1b3d"; + const mutedText = "rgba(15, 27, 54, 0.66)"; + + function rgba(color, opacity) { + const c = d3.rgb(color); + return `rgba(${c.r}, ${c.g}, ${c.b}, ${opacity})`; + } + + const xColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const yColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const dimensionField = xColumn.name || chartUtils.schema.column(dataColumns, 0).raw?.name || "dimension"; + const valueField = yColumn.name || chartUtils.schema.column(dataColumns, 1).raw?.name || "value"; + const dimensionUnit = xColumn.unit && xColumn.unit !== "none" ? xColumn.unit : ""; + const valueUnit = yColumn.unit && yColumn.unit !== "none" ? yColumn.unit : ""; + + function parseTemporalSortValue(value) { + const text = String(value ?? "").trim(); + let match = text.match(/^(-?\d{1,6})$/); + if (match) return Number(match[1]); + match = text.match(/^(-?\d{1,6})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) { + return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + } + const dateValue = Date.parse(text); + return Number.isNaN(dateValue) ? NaN : dateValue; + } + + function formatNumber(value) { + const numericValue = Number(value); + if (!Number.isFinite(numericValue)) return String(value ?? ""); + if (Number.isInteger(numericValue)) return d3.format(".0f")(numericValue); + return d3.format(".4~f")(numericValue); + } + + function formatWithUnit(value, unit) { + const formatted = formatNumber(value); + if (!unit) return formatted; + if (unit === "$") return `$${formatted}`; + if (unit === "%") return `${formatted}%`; + return `${formatted} ${unit}`; + } + + function dimensionLabel(d) { + const value = d[dimensionField]; + return dimensionUnit ? `${value} ${dimensionUnit}` : String(value ?? ""); + } + + function prettifyHeader(value, fallback) { + const text = String(value || fallback || "").trim(); + if (!text) return ""; + return text + .replace(/[_-]+/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .toUpperCase(); + } + + const enrichedData = chartData.map((d, index) => ({ + ...d, + __index: index, + __dimension: dimensionLabel(d), + __value: Number(d[valueField]) + })).filter(d => Number.isFinite(d.__value)); + + const temporalValues = enrichedData.map(d => parseTemporalSortValue(d[dimensionField])); + const isTemporal = xColumn.data_type === "temporal" || ( + temporalValues.length > 0 && temporalValues.every(Number.isFinite) + ); + + const sortedData = [...enrichedData].sort((a, b) => { + if (isTemporal) { + const aTime = parseTemporalSortValue(a[dimensionField]); + const bTime = parseTemporalSortValue(b[dimensionField]); + if (Number.isFinite(aTime) && Number.isFinite(bTime)) return aTime - bTime; + } + const byValue = b.__value - a.__value; + if (byValue !== 0) return byValue; + return String(a.__dimension).localeCompare(String(b.__dimension)); + }); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg"); + + const defs = svg.append("defs"); + const gradientId = "horizontal-dot-bar-gradient"; + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", amber); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#f6bd16"); + + if (variables.has_shadow) { + const shadow = defs.append("filter") + .attr("id", "dot-shadow") + .attr("x", "-40%") + .attr("y", "-40%") + .attr("width", "180%") + .attr("height", "180%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 1) + .attr("stdDeviation", 1.4) + .attr("flood-color", "#000000") + .attr("flood-opacity", 0.18); + } + + const measureSvg = svg.append("g").attr("visibility", "hidden"); + function measureLabelText(text, fontSize, family, weight) { + const node = measureSvg.append("text") + .style("font-family", family) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight) + .text(text) + .node(); + const width = node ? node.textContent.length * 7 : String(text).length * fontSize * 0.55; + measureSvg.selectAll("text").remove(); + return width; + } + + function breakLongWord(word, maxWidth, fontSize, family, weight) { + const lines = []; + let current = ""; + for (const char of String(word)) { + const next = current + char; + if (current && measureLabelText(next, fontSize, family, weight) > maxWidth) { + lines.push(`${current}-`); + current = char; + } else { + current = next; + } + } + if (current) lines.push(current); + return lines.length ? lines : [String(word)]; + } + + function wrapText(text, maxWidth, fontSize, family, weight) { + const words = String(text || "").split(/\s+/).filter(Boolean); + if (!words.length) return [String(text || "")]; + const lines = []; + let current = ""; + for (const word of words) { + const candidate = current ? `${current} ${word}` : word; + if (measureLabelText(candidate, fontSize, family, weight) <= maxWidth) { + current = candidate; + continue; + } + if (current) lines.push(current); + if (measureLabelText(word, fontSize, family, weight) <= maxWidth) { + current = word; + } else { + const broken = breakLongWord(word, maxWidth, fontSize, family, weight); + lines.push(...broken.slice(0, -1)); + current = broken[broken.length - 1]; + } + } + if (current) lines.push(current); + return lines.length ? lines : [String(text || "")]; + } + + function truncateText(text, maxChars) { + const value = String(text || ""); + if (value.length <= maxChars) return value; + return value.slice(0, Math.max(0, maxChars)).trim(); + } + + function titleCaseHeader(value, fallback) { + const text = String(value || fallback || "").trim() + .replace(/[_-]+/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " "); + if (!text) return ""; + return text.replace(/\w\S*/g, word => word.charAt(0).toUpperCase() + word.slice(1)); + } + + function appendReferenceIcon(parent, x, y, size, className, color = navy) { + const g = parent.append("g") + .attr("class", className || "reference-icon") + .attr("transform", `translate(${x}, ${y})`); + g.append("circle") + .attr("cx", size / 2) + .attr("cy", size / 2) + .attr("r", size / 2) + .attr("fill", color); + const glyph = g.append("g") + .attr("class", "reference-icon-glyph") + .attr("fill", "none") + .attr("stroke", "#ffffff") + .attr("stroke-width", Math.max(1.1, size * 0.065)) + .attr("stroke-linecap", "round") + .attr("stroke-linejoin", "round"); + glyph.append("rect") + .attr("x", size * 0.28) + .attr("y", size * 0.38) + .attr("width", size * 0.44) + .attr("height", size * 0.32) + .attr("rx", size * 0.04); + glyph.append("path") + .attr("d", `M${size * 0.28},${size * 0.49} L${size * 0.5},${size * 0.3} L${size * 0.72},${size * 0.49}`); + [0.37, 0.5, 0.63].forEach((px, index) => { + glyph.append("line") + .attr("x1", size * px) + .attr("x2", size * px) + .attr("y1", size * (0.62 - index * 0.055)) + .attr("y2", size * 0.7); + }); + return g; + } + + function splitValueLabel(label, unit) { + const text = String(label || ""); + if (unit && text.endsWith(` ${unit}`)) { + return [text.slice(0, -unit.length - 1), unit]; + } + return [text, ""]; + } + + svg.append("rect") + .attr("class", "chart-style-background") + .attr("width", width) + .attr("height", height) + .attr("fill", "#fbfcff"); + + const cardX = Math.max(46, width * 0.035); + const cardY = 18; + const cardWidth = width - cardX * 2; + const cardPad = Math.max(26, Math.min(40, width * 0.028)); + const tableY = cardY; + const headerHeight = 54; + const rowHeight = rowCount > 14 ? 34 : (rowCount > 10 ? 39 : 54); + const innerHeight = Math.max(rowCount * rowHeight, rowCount * 32); + const tableHeight = headerHeight + innerHeight + 24; + const cardHeight = tableHeight; + const dynamicHeight = Math.max(baseHeight, cardY * 2 + cardHeight); + svg.attr("height", dynamicHeight).attr("viewBox", `0 0 ${width} ${dynamicHeight}`); + + const labelMaxWidth = Math.min(340, cardWidth * 0.27); + const valueLabels = sortedData.map(d => formatWithUnit(d.__value, valueUnit)); + const maxValueLabelWidth = Math.max( + 46, + ...valueLabels.map(label => measureLabelText(label, baseValueSize, valueFamily, valueWeight)) + ); + const iconColumnWidth = 88; + const valueColumnWidth = Math.max(96, maxValueLabelWidth + 44); + const labelFontSize = Math.max(10, Math.min(baseLabelSize, rowHeight * 0.42)); + const wrappedLabels = sortedData.map(d => wrapText(d.__dimension, labelMaxWidth, labelFontSize, labelFamily, labelWeight)); + const maxLabelLineWidth = Math.max( + 54, + ...wrappedLabels.flat().map(line => measureLabelText(line, labelFontSize, labelFamily, labelWeight)) + ); + const labelColumnWidth = Math.max(248, Math.min(cardWidth * 0.28, maxLabelLineWidth + 76)); + measureSvg.remove(); + + const tableX = cardX + cardPad; + const tableWidth = cardWidth - cardPad * 2; + const chartX = tableX + iconColumnWidth + labelColumnWidth + 24; + const valueColumnX = tableX + tableWidth - valueColumnWidth; + const innerWidth = Math.max(300, valueColumnX - chartX - 34); + const chartY = tableY + headerHeight + 2; + const yScale = d3.scaleBand() + .domain(sortedData.map(d => `${d.__dimension}__${d.__index}`)) + .range([0, innerHeight]) + .padding(0.18); + + const values = sortedData.map(d => d.__value); + let minValue = Math.min(0, d3.min(values) ?? 0); + let maxValue = Math.max(0, d3.max(values) ?? 0); + if (minValue === maxValue) { + maxValue = maxValue === 0 ? 1 : maxValue * 1.1; + minValue = 0; + } + const xScale = d3.scaleLinear() + .domain([minValue, maxValue]) + .range([0, innerWidth]); + const zeroX = xScale(0); + + const panel = svg.append("g") + .attr("class", "chart-style-panel"); + + if (variables.has_shadow) { + panel.append("rect") + .attr("x", cardX + 2) + .attr("y", cardY + 3) + .attr("width", cardWidth) + .attr("height", cardHeight) + .attr("rx", 16) + .attr("fill", "rgba(15, 27, 54, 0.08)"); + } + + panel.append("rect") + .attr("class", "reference-panel") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardWidth) + .attr("height", cardHeight) + .attr("rx", 16) + .attr("fill", "#ffffff") + .attr("stroke", "rgba(15, 27, 54, 0.10)") + .attr("stroke-width", 1); + + const axisTitle = titleCaseHeader(yColumn.name, "Value"); + const categoryTitle = titleCaseHeader(xColumn.name, "Category"); + const valueHeader = valueUnit ? `Value (${valueUnit})` : "Value"; + + panel.append("rect") + .attr("class", "plot-background") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardWidth) + .attr("height", cardHeight) + .attr("rx", 16) + .attr("fill", "none") + .attr("stroke", "none"); + + const headerFontSize = Math.max(10, Math.min(13, baseLabelSize * 0.92)); + const categoryHeader = categoryTitle.toLowerCase() === "city" ? "City District" : categoryTitle; + const headerLabels = [ + { + text: categoryHeader.toUpperCase(), + x: tableX + iconColumnWidth + 22, + anchor: "start" + }, + { + text: axisTitle.toUpperCase(), + x: chartX + (innerWidth + valueColumnWidth) / 2, + anchor: "middle" + } + ]; + + panel.selectAll(".table-header-label") + .data(headerLabels) + .enter() + .append("text") + .attr("class", "table-header-label") + .attr("x", d => d.x) + .attr("y", tableY + headerHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", d => d.anchor) + .style("font-family", labelFamily) + .style("font-size", `${headerFontSize}px`) + .style("font-weight", 700) + .style("fill", navy) + .style("letter-spacing", "0px") + .text(d => d.text); + + panel.append("line") + .attr("class", "table-header-rule") + .attr("x1", tableX + 4) + .attr("x2", tableX + tableWidth - 4) + .attr("y1", tableY + headerHeight) + .attr("y2", tableY + headerHeight) + .attr("stroke", "rgba(15, 27, 54, 0.22)") + .attr("stroke-width", 1); + + const plot = svg.append("g") + .attr("transform", `translate(${chartX}, ${chartY})`); + + plot.selectAll(".row-separator") + .data(sortedData) + .enter() + .append("line") + .attr("class", "row-separator") + .attr("x1", tableX - chartX + 4) + .attr("x2", tableX - chartX + tableWidth - 4) + .attr("y1", d => (yScale(`${d.__dimension}__${d.__index}`) || 0) + yScale.bandwidth() + yScale.step() * yScale.paddingInner() / 2) + .attr("y2", d => (yScale(`${d.__dimension}__${d.__index}`) || 0) + yScale.bandwidth() + yScale.step() * yScale.paddingInner() / 2) + .attr("stroke", "rgba(15, 27, 54, 0.08)") + .attr("stroke-width", 1); + + const rowGroups = plot.selectAll(".row") + .data(sortedData) + .enter() + .append("g") + .attr("class", "row") + .attr("transform", d => `translate(0, ${yScale(`${d.__dimension}__${d.__index}`)})`); + + rowGroups.append("rect") + .attr("class", "row-band") + .attr("x", tableX - chartX + 4) + .attr("y", 0) + .attr("width", tableWidth - 8) + .attr("height", yScale.bandwidth()) + .attr("fill", "transparent"); + + const trackHeight = Math.max(8, Math.min(15, yScale.bandwidth() * 0.42)); + const dotRadius = Math.max(3.2, Math.min(5.4, yScale.bandwidth() * 0.18)); + const valueFontSize = Math.max(10, Math.min(baseValueSize + 1, yScale.bandwidth() * 0.42)); + const rowCenter = yScale.bandwidth() / 2; + + rowGroups.each(function() { + appendReferenceIcon( + d3.select(this), + tableX - chartX + 18, + rowCenter - 15, + 30, + "rank-badge row-icon", + navy + ); + }); + + rowGroups.append("line") + .attr("class", "dot-bar-track") + .attr("x1", zeroX) + .attr("x2", innerWidth) + .attr("y1", rowCenter) + .attr("y2", rowCenter) + .attr("stroke", "rgba(15, 27, 54, 0.07)") + .attr("stroke-width", trackHeight) + .attr("stroke-linecap", "round"); + + rowGroups.append("line") + .attr("class", "dot-bar bar") + .attr("x1", zeroX) + .attr("x2", d => xScale(d.__value)) + .attr("y1", rowCenter) + .attr("y2", rowCenter) + .attr("stroke", amber) + .attr("stroke-width", trackHeight) + .attr("stroke-linecap", "round") + .attr("opacity", 0.96); + + rowGroups.append("circle") + .attr("class", "dot mark") + .attr("cx", d => xScale(d.__value)) + .attr("cy", rowCenter) + .attr("r", dotRadius) + .attr("fill", amber) + .attr("stroke", amber) + .attr("stroke-width", 0) + .style("filter", variables.has_shadow ? "url(#dot-shadow)" : "none"); + + rowGroups.each(function(d, rowIndex) { + const lines = wrappedLabels[rowIndex] || [d.__dimension]; + const lineHeight = labelFontSize * 1.08; + const startY = rowCenter - ((lines.length - 1) * lineHeight) / 2; + const label = d3.select(this).append("text") + .attr("class", "label") + .attr("x", tableX - chartX + iconColumnWidth + 22) + .attr("y", startY) + .attr("text-anchor", "start") + .style("font-family", labelFamily) + .style("font-size", `${labelFontSize}px`) + .style("font-weight", 700) + .style("fill", navy); + lines.forEach((line, lineIndex) => { + label.append("tspan") + .attr("x", tableX - chartX + iconColumnWidth + 22) + .attr("dy", lineIndex === 0 ? "0.35em" : `${lineHeight}px`) + .text(line); + }); + }); + + rowGroups.each(function(d) { + const [numberPart, unitPart] = splitValueLabel(formatWithUnit(d.__value, valueUnit), valueUnit); + const value = d3.select(this).append("text") + .attr("class", "value") + .attr("x", valueColumnX - chartX + valueColumnWidth - 12) + .attr("y", rowCenter) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", valueFamily) + .style("font-size", `${valueFontSize}px`) + .style("fill", navy); + value.append("tspan") + .attr("class", "value-number") + .style("font-weight", 800) + .text(numberPart); + if (unitPart) { + value.append("tspan") + .attr("class", "value-unit") + .style("font-weight", valueWeight) + .style("fill", mutedText) + .text(` ${unitPart}`); + } + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..091e41388d9f86d589cb1d1402ffafbcd2652eb6 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_dot_bar_chart_02.js @@ -0,0 +1,614 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Dot Bar Chart", + "chart_name": "horizontal_dot_bar_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[5, 30], [0, 20]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["shadow", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 百分比竖条图实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#FFBB33" } // 默认橙黄色 + }; + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : true; + variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; + variables.has_gradient = true; // 确保渐变被启用 + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : true; + + // 数值格式化函数 + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 40, // 底部边距 + left: 100 // 左侧足够空间用于维度标签 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit || ""; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit || ""; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值并按数值降序排列数据 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const maxValue_ = d3.max(chartData, d => Math.abs(+d[valueField])); + + // 计算每个棒子表示的单位数量 + // 目标：最大值对应的棒子数量在20-50之间 + const targetMaxBars = 35; // 选择目标范围(20-50)的中间值 + const unitPerBar = Math.ceil(maxValue_ / targetMaxBars); + + // 为每个数据点计算应显示的棒子数量 + chartData.forEach(d => { + // 原始数值保存在 valueField + // 转换后的棒子数量保存在 valueField_ + d[`${valueField}_`] = Math.max(0.1, +d[valueField] / unitPerBar); + }); + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // ---------- 5. 布局计算和字体调整 ---------- + + const dimLabelMaxWidth = width * 0.25; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + // 计算行间距 + const rowPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(rowPadding); + + const rowHeight = yScale.bandwidth(); + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: sortedDimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: rowHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算最大数值标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[`${valueField}_`]}${valueUnit}` : + `${d[`${valueField}_`]}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + tempSvg.remove(); + + // 根据标签宽度调整左边距 + margin.left = maxLabelWidth + 15; + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // 计算行高和棒子高度（提前定义供图例使用） + const barHeight = Math.min(rowHeight * 0.7, 30); // 棒子高度限制在30px以内 + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 2); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 获取主要颜色 + const primaryColor = colorResolver.other("primary", { fallback: "#FFBB33" }).value; + + // 创建每10个棒子一组的渐变定义 + const maxGroups = 10; // 假设最多10组（即最大100%） + for (let group = 0; group < maxGroups; group++) { + // 为每组创建渐变 + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + // 计算此组的亮度偏移 + // 随着组号增加，整体颜色变深 + const groupDarkenFactor = 0.2 * group; + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 1.0 - groupDarkenFactor })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "darker", amount: 0.0 + groupDarkenFactor })); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值，确保所有棒子能够显示 + const maxValue = d3.max(chartData, d => +d[`${valueField}_`]); + + // 计算适合当前宽度的棒子尺寸 + const availableWidth = innerWidth; + + // 计算合适的棒子尺寸，确保所有数据都能显示 + // 默认值 + const defaultBarWidth = 30; + const defaultBarSpacing = 5; + const largerGroupSpacing = 15; // 每10个棒子后的额外间距 + + // 棒子组大小（每组10个） + const groupSize = 5; + + // 计算一组10个棒子需要的宽度（包括普通间距） + const groupBaseWidth = groupSize * defaultBarWidth + (groupSize - 1) * defaultBarSpacing; + + // 计算需要多少组 + const requiredGroups = Math.ceil(maxValue / groupSize); + + // 计算总需要宽度（包括组间额外间距） + const requiredWidth = requiredGroups * groupBaseWidth + (requiredGroups - 1) * largerGroupSpacing; + + // 如果需要的宽度大于可用宽度，则缩放 + let barWidth, barSpacing, groupSpacing; + + if (requiredWidth > availableWidth) { + const scaleFactor = availableWidth / requiredWidth; + barWidth = Math.max(3, Math.floor(defaultBarWidth * scaleFactor)); + barSpacing = Math.max(1, Math.floor(defaultBarSpacing * scaleFactor)); + groupSpacing = Math.max(3, Math.floor(largerGroupSpacing * scaleFactor)); + } else { + barWidth = defaultBarWidth; + barSpacing = defaultBarSpacing; + groupSpacing = largerGroupSpacing; + } + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + + + // ---------- 10. 绘制百分比竖条图和标签 ---------- + + // 为每个维度绘制竖条组和标签 + sortedDimensions.forEach(dimension => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + const rowHeight = yScale.bandwidth(); + const barHeight = rowHeight; // 竖条高度为行高 + const barY = yScale(dimension) + (rowHeight - barHeight) / 2; // 竖条垂直居中 + const barCount = Math.floor(dataPoint[`${valueField}_`]); // 向下取整到整数 + const partialBar = dataPoint[`${valueField}_`] - barCount; // 计算小数部分 + + // 绘制竖条组 + for (let i = 0; i < barCount; i++) { + // 计算当前棒子所在的组（每5个一组） + const groupIndex = Math.floor(i / groupSize); + // 计算在当前组内的索引（0-4） + const inGroupIndex = i % groupSize; + + // 计算x位置（考虑组间的额外间距） + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + groupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 获取当前组的渐变ID + const gradientId = `bar-gradient-${groupIndex}`; + + // 绘制单个竖条 + g.append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("xlink:href", jsonData.images.field[dataPoint[dimensionField]]); + } + + // 如果有小数部分，绘制部分宽度的最后一个竖条 + if (partialBar > 0) { + const groupIndex = Math.floor(barCount / groupSize); + const inGroupIndex = barCount % groupSize; + + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + groupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 使用SVG裁剪方式实现部分图像显示 + const imageWidth = barWidth * partialBar; + + // 方法一：使用裁剪路径实现部分图像显示 + // 创建唯一的裁剪路径ID + const clipPathId = `clip-path-${dimension.replace(/\s+/g, '-')}-${barCount}`; + + // 在defs中定义裁剪路径 - 注意：clipPath采用用户坐标系统 + defs.append("clipPath") + .attr("id", clipPathId) + .attr("clipPathUnits", "userSpaceOnUse") // 使用用户坐标系而非对象坐标系 + .append("rect") + .attr("x", barX) // 使用与图像相同的x坐标 + .attr("y", barY) // 使用与图像相同的y坐标 + .attr("width", imageWidth) + .attr("height", barHeight); + + // 使用裁剪路径显示部分图像 + g.append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) // 保持原始宽度 + .attr("height", barHeight) + .attr("clip-path", `url(#${clipPathId})`) + .attr("xlink:href", jsonData.images.field[dataPoint[dimensionField]]); + } + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const centerY = yScale(dimension) + rowHeight / 2; + const labelGroup = g.append("text") + .attr("x", -10) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", -10) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 计算动态字体大小（条形高度的60%） + const dynamicFontSize = `${barHeight * 0.8}px`; + + // 计算最后一个棒子的位置，用于放置数值标签 + const lastGroupIndex = Math.floor(barCount / groupSize); + const lastInGroupIndex = barCount % groupSize; + let lastBarX = (lastGroupIndex * (groupSize * (barWidth + barSpacing) + groupSpacing)) + + (lastInGroupIndex * (barWidth + barSpacing)); + + // 如果有小数部分，调整标签位置 + if (partialBar > 0) { + lastBarX += barWidth * partialBar; + } else { + lastBarX += barWidth; + } + + g.append("text") + .attr("x", lastBarX + 5) + .attr("y", yScale(dimension) + rowHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", dynamicFontSize) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..18e46d98895b4cc5f9d01ccf1328413ad0ef59cb --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01.js @@ -0,0 +1,394 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 10]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_grouped_bar_chart_01 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(null, dimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size + }).width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const textWidth = chartUtils.text.measure(null, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // === 修改点：结合维度标签和组标签最大宽度，重新计算margin.left === + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算每组需要的垂直空间 + const groupHeight = innerHeight / groups.length; + const groupPadding = innerHeight * (variables.has_spacing ? 0.08 : 0.06); // 组间距 + + // 每个维度的条形高度 + const barHeight = (groupHeight - groupPadding) / dimensions.length; + const actualBarHeight = variables.has_spacing ? barHeight * 0.65 : barHeight * 0.75; // 实际条形高度 + + // 标志尺寸 + const iconWidth = actualBarHeight * 0.9; + const iconHeight = iconWidth; + const iconRightPadding = iconWidth * 0.4; // 图标右侧到柱子的间距 + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 1.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.7 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + const groupIndex = groups.indexOf(group); + const availableColor = colorResolver.available(groupIndex, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + + + } + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; // 默认颜色 + }; + + // ========== 9. 添加交替行背景（新增） ========== + if (jsonData.variation?.background === "styled") { + // 每个 group 下有若干维度，故在每个 group 里为维度的"行"画背景 + groups.forEach((group, groupIndex) => { + const groupStartY = groupIndex * groupHeight; + dimensions.forEach((dimension, dimIndex) => { + // 偶数行添加背景 + if (dimIndex % 2 === 0) { + g.append("rect") + .attr("x", 0) + .attr("y", groupStartY + dimIndex * barHeight) + .attr("width", innerWidth) + .attr("height", barHeight) + .attr("class","background") + .attr("fill", "#f5f5f5") + .attr("opacity", 0.8); + } + }); + }); + } + + // ---------- 10. 绘制图表 ---------- + + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 计算该组的垂直位置 + const groupStartY = groupIndex * (groupHeight); + + // === 修改点：组标签与条形标签右对齐，而非原先居中 === + const groupLabelOffsetX = -(iconWidth + iconRightPadding + 5); + g.append("text") + .attr("x", groupLabelOffsetX) + .attr("y", groupStartY - parseFloat(typography.label.font_size)/2-5) // 略微上移 + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + + // 为每个维度绘制条形 + dimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置 + const barY = groupStartY + dimIndex * barHeight; + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + actualBarHeight / 2})`); + + // 绘制图标 + if (images.field && images.field[dimension]) { + // 图标位置：紧贴条形左侧 + labelGroup.append("image") + .attr("x", -iconWidth - iconRightPadding) + .attr("y", -iconHeight/2) + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", -iconWidth - iconRightPadding - 5) // 图标左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.min(barHeight * 0.9, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(dimension); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", actualBarHeight) // 略小于计算高度，留出间距 + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getGroupColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${barHeight * 0.55}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 计算文本位置 - 默认在条形中间 + let textX = barWidth / 2; + + // 确保文本末尾不超出条形右侧边界 + if (textX + textWidth/2 > barWidth) { + textX = barWidth - textWidth/2 - 2; + } + g.append("text") + .attr("x", barWidth + 8) // 条形右侧5像素处 + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${barHeight * 0.55}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + + } + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..ab9737dbf3161c04769b642e946193ae6e63bfa4 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_01_hand.js @@ -0,0 +1,416 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_01_hand", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 10]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(null, dimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size + }).width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const textWidth = chartUtils.text.measure(null, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // === 修改点：结合维度标签和组标签最大宽度，重新计算margin.left === + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算每组需要的垂直空间 + const groupHeight = innerHeight / groups.length; + const groupPadding = innerHeight * (variables.has_spacing ? 0.08 : 0.06); // 组间距 + + // 每个维度的条形高度 + const barHeight = (groupHeight - groupPadding) / dimensions.length; + const actualBarHeight = variables.has_spacing ? barHeight * 0.65 : barHeight * 0.75; // 实际条形高度 + + // 标志尺寸 + const iconWidth = actualBarHeight * 0.9; + const iconHeight = iconWidth; + const iconRightPadding = iconWidth * 0.4; // 图标右侧到柱子的间距 + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 1.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.7 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + const groupIndex = groups.indexOf(group); + const availableColor = colorResolver.available(groupIndex, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + + + } + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; // 默认颜色 + }; + + // ========== 9. 添加交替行背景（新增） ========== + if (jsonData.variation?.background === "styled") { + // 每个 group 下有若干维度，故在每个 group 里为维度的"行"画背景 + groups.forEach((group, groupIndex) => { + const groupStartY = groupIndex * groupHeight; + dimensions.forEach((dimension, dimIndex) => { + // 偶数行添加背景 + if (dimIndex % 2 === 0) { + g.append("rect") + .attr("x", 0) + .attr("y", groupStartY + dimIndex * barHeight) + .attr("width", innerWidth) + .attr("height", barHeight) + .attr("class","background") + .attr("fill", "#f5f5f5") + .attr("opacity", 0.8); + } + }); + }); + } + + // ---------- 10. 绘制图表 ---------- + + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 计算该组的垂直位置 + const groupStartY = groupIndex * (groupHeight); + + // === 修改点：组标签与条形标签右对齐，而非原先居中 === + const groupLabelOffsetX = -(iconWidth + iconRightPadding + 5); + g.append("text") + .attr("x", groupLabelOffsetX) + .attr("y", groupStartY - parseFloat(typography.label.font_size)/2-5) // 略微上移 + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", "bold") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + + // 为每个维度绘制条形 + dimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置 + const barY = groupStartY + dimIndex * barHeight; + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + actualBarHeight / 2})`); + + // 绘制图标 + if (images.field && images.field[dimension]) { + // 图标位置：紧贴条形左侧 + labelGroup.append("image") + .attr("x", -iconWidth - iconRightPadding) + .attr("y", -iconHeight/2) + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", -iconWidth - iconRightPadding - 5) // 图标左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.min(barHeight * 0.9, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(dimension); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", actualBarHeight) // 略小于计算高度，留出间距 + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getGroupColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${barHeight * 0.55}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 计算文本位置 - 默认在条形中间 + let textX = barWidth / 2; + + // 确保文本末尾不超出条形右侧边界 + if (textX + textWidth/2 > barWidth) { + textX = barWidth - textWidth/2 - 2; + } + g.append("text") + .attr("x", barWidth + 8) // 条形右侧5像素处 + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${barHeight * 0.55}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + + } + }); + }); + + const roughness = 1; + const bowing = 2; + const fillStyle = "hachure"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..6c1368ae1864bc2a51cc749937d5ff47ead64c94 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_02.js @@ -0,0 +1,424 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_02", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "hierarchy":["group"], + "required_fields_range": [[2, 30], [0, "inf"], [2, 10]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "hierarchy":["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平条形图 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + const jsonData = data; + const chartData = jsonData.data.data + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = chartUtils.schema.columns(jsonData); + + // 设置图表视觉效果 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || true; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段 ---------- + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 单位 (若有) + let valueUnit = ""; + if (dimensionChannel.unit) { + valueUnit = dimensionChannel.unit; + } + if (valueChannel.unit) { + valueUnit = valueChannel.unit; + } + if (groupChannel.unit) { + valueUnit = groupChannel.unit; + } + + // ---------- 3. 数据排序 ---------- + const groups = [...new Set(chartData.map(d => d[groupField]))]; + chartData.sort((a, b) => { + const vc = +a[valueField] - +b[valueField]; + if (vc !== 0) return vc; + return String(a[dimensionField]).localeCompare(String(b[dimensionField])); + }); + const dimensions = chartData.map(d => d[dimensionField]); + + // ---------- 4. 布局 ---------- + const width = variables.width || 600; + const height = variables.height || 600; + + const margin = { + top: 50, + right: width*0.4, + bottom: 90, + left: 40 + }; + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + const barHeight = innerHeight / dimensions.length; + const actualBarHeight = barHeight * 0.75; + const iconWidth = actualBarHeight * 0.85; + const iconHeight = iconWidth; + const iconRightPadding = - iconWidth * 0.3; + + // ---------- 5. 创建SVG ---------- + d3.select(containerSelector).html(""); + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .style("max-width", "100%") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + const defs = svg.append("defs"); + + // ---------- 6. 视觉效果 (阴影/渐变) ---------- + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result","offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in","SourceGraphic"); + } + + // 渐变 + if (variables.has_gradient) { + groups.forEach(grp => { + const gradientId = `gradient-${grp.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(grp); + + const grad = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + grad.append("stop") + .attr("offset","0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.2 })); + grad.append("stop") + .attr("offset","100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.2 })); + }); + } + + // ---------- 7. 比例尺 ---------- + const maxValue = d3.max(chartData, d => +d[valueField]); + const xScale = d3.scaleLinear() + .domain([0, maxValue]) + .range([0, innerWidth]); + + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(0.1); + + // ---------- 8. 主容器 ---------- + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 工具函数 ---------- + function getGroupColor(grp) { + if (colorResolver.field(grp, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(grp, 0, { fallbackKey: "primary" }).value; + } + const idx = groups.indexOf(grp); + const availableColor = colorResolver.available(idx, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + const defaultSet = d3.schemeTableau10; + return defaultSet[idx % defaultSet.length]; + } + + function getStrokeColor() { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333" }).value; + } + + function measureTextWidth(txt, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(svg, txt, { fontFamily: fontFamily, fontSize: parseFloat(fontSize) || fontSize, fontWeight: fontWeight }).width; + } + + // ---------- 10. 绘制 ---------- + // 10.1 收集相同value的bar位置 + const barPositionsByValue = {}; + + // 绘制所有bar + chartData.forEach(d => { + const dimension = d[dimensionField]; + const value = +d[valueField]; + const grp = d[groupField]; + + const barColor = getGroupColor(grp); + + const barY = yScale(dimension); + const centerY = barY + yScale.bandwidth()/2; + + g.append("rect") + .attr("x",0) + .attr("y",barY) + .attr("width", xScale(value)) + .attr("height", actualBarHeight) + .attr("fill", barColor) + .attr("rx", variables.has_rounded_corners?3:0) + .attr("ry", variables.has_rounded_corners?3:0) + .style("stroke", variables.has_stroke? getStrokeColor():"none") + .style("stroke-width", variables.has_stroke?1:0) + .style("filter", variables.has_shadow?"url(#shadow)":"none") + .attr("transform",`translate(0, ${(yScale.bandwidth()-actualBarHeight)/2})`); + + // 如果有图标 + if (images.field && images.field[dimension]) { + g.append("circle") + .attr("cx", iconRightPadding) + .attr("cy", centerY) + .attr("r", iconWidth*0.7) + .attr("fill","white"); + g.append("circle") + .attr("cx", iconRightPadding) + .attr("cy", centerY) + .attr("r", iconWidth*0.6) + .attr("fill","none") + .attr("stroke","#000") + .attr("stroke-width",0.5); + g.append("image") + .attr("x", iconRightPadding - iconWidth/2) + .attr("y", centerY - iconHeight/2) + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 自适应维度文字 + let fs = actualBarHeight*0.8; + let fit = false; + while(!fit && fs>4){ + const txtW = measureTextWidth( + dimension, + typography.label.font_family, + `${fs}px`, + typography.label.font_weight + ); + if (txtW + iconWidth < xScale(value)-10) fit=true; + else fs-=1; + } + g.append("text") + .attr("x", iconWidth*0.9) + .attr("y", centerY) + .attr("dy","0.35em") + .style("font-family", typography.label.font_family) + .style("font-size", `${fs}px`) + .style("font-weight", typography.label.font_weight) + .style("fill","#fff") + .text(dimension); + + // 收集bar的中心位置 + if(!barPositionsByValue[value]){ + barPositionsByValue[value]=[]; + } + barPositionsByValue[value].push(centerY); + }); + + // ---------- 10.2 绘制大括号：有上下横线+竖线，只在文字处挖空 ---------- + Object.keys(barPositionsByValue).forEach(valStr=>{ + const val = +valStr; + const centers = barPositionsByValue[val]; + centers.sort((a,b)=>a-b); + + // 只有1条柱形就简单写数值 + if (centers.length===1) { + g.append("text") + .attr("x", xScale(val)+5) + .attr("y", centers[0]) + .attr("dy","0.35em") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(valueUnit? chartUtils.format.autoText(val)+valueUnit : chartUtils.format.autoText(val)); + } else { + // 多条bar => 计算顶部、底部和中间 + const topY = centers[0] - actualBarHeight/2; + const bottomY = centers[centers.length-1] + actualBarHeight/2; + const midY = (topY + bottomY)/2; + + // 估算文字高度 + const fontSizeNum = parseFloat(typography.annotation.font_size) || 12; + // 留出一点额外空隙，防止文字贴在竖线上 + const offset = (fontSizeNum*0.6); + + // 括号位置 & 横线长度 + const bracketX = xScale(val) + 5; + const bracketWidth = 10; + + // 1) 画"上横线" + // M bracketX, topY -> h bracketWidth + const pathTopLine = [ + `M ${bracketX},${topY}`, + `h ${bracketWidth}` + ].join(" "); + g.append("path") + .attr("d", pathTopLine) + .attr("fill","none") + .attr("stroke", colorResolver.text({ fallback: "#333" }).value) + .attr("stroke-width",1); + + // 2) 画"下横线" + // M bracketX, bottomY -> h bracketWidth + const pathBottomLine = [ + `M ${bracketX},${bottomY}`, + `h ${bracketWidth}` + ].join(" "); + g.append("path") + .attr("d", pathBottomLine) + .attr("fill","none") + .attr("stroke", colorResolver.text({ fallback: "#333" }).value) + .attr("stroke-width",1); + + // 3) 画竖线的上半段 + // 从( bracketX+bracketWidth, topY )到( bracketX+bracketWidth, midY - offset ) + const pathVerticalTop = [ + `M ${bracketX+bracketWidth},${topY}`, + `V ${midY - offset}` + ].join(" "); + g.append("path") + .attr("d", pathVerticalTop) + .attr("fill","none") + .attr("stroke", colorResolver.text({ fallback: "#333" }).value) + .attr("stroke-width",1); + + // 4) 画竖线的下半段 + // 从( bracketX+bracketWidth, midY + offset )到( bracketX+bracketWidth, bottomY ) + const pathVerticalBottom = [ + `M ${bracketX+bracketWidth},${midY + offset}`, + `V ${bottomY}` + ].join(" "); + g.append("path") + .attr("d", pathVerticalBottom) + .attr("fill","none") + .attr("stroke", colorResolver.text({ fallback: "#333" }).value) + .attr("stroke-width",1); + + // 5) 在中间放文字 + // x 取 ( bracketX + bracketWidth + 一点偏移 )，也可取 bracketX + bracketWidth/2 + // 这里示例靠右一点 anchor = start + g.append("text") + .attr("x", bracketX + bracketWidth/2) + .attr("y", midY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(valueUnit? chartUtils.format.autoText(val)+valueUnit : chartUtils.format.autoText(val)); + } + }); + + // ---------- 10.3 添加y轴标签 ---------- + const lastDimension = dimensions[dimensions.length - 1]; + const lastBarY = yScale(lastDimension) + yScale.bandwidth(); + const yAxisLabel = chartUtils.schema.columnField(dataColumns, 1, ""); + + const yAxisLabelElement = svg.append("text") + .attr("x", margin.left + iconRightPadding) + .attr("y", margin.top + lastBarY + 40) + .attr("text-anchor", "start") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(yAxisLabel); + + const yAxisLabelWidth = chartUtils.text.measure(svg, yAxisLabel, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const yAxisLabelX = margin.left + iconRightPadding; + const yAxisLabelY = margin.top + lastBarY + 40; + + // ---------- 10.4 添加图例 ---------- + const legendStartX = yAxisLabelX + yAxisLabelWidth + 200; + const legendWidth = width - legendStartX - 20; + const legendY = yAxisLabelY - 15; + + chartUtils.legend.strip(svg, groups, { + color: group => getGroupColor(group), + colorResolver, + colors, + }, { + x: legendStartX, + y: legendY, + width: legendWidth, + barHeight: 10, + labelGap: 10, + maxFontSize: 14, + minFontSize: 6, + fontFamily: typography.annotation.font_family, + fontWeight: typography.annotation.font_weight, + textColor: colorResolver.text({ fallback: "#333" }).value, + toUpperCase: true, + trackFill: "#f5f5f5", + trackStroke: "#ccc", + markerRadius: 3, + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03.js new file mode 100644 index 0000000000000000000000000000000000000000..f0244a33f32cc29f7ef87ecfdd7daafe758f2d02 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03.js @@ -0,0 +1,495 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_03", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 8], [0, "inf"], [2, 6]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + let dimensionField = '', valueField = '', groupField = ''; + + try { + dimensionField = chartUtils.schema.channel(jsonData, "x").key; + valueField = chartUtils.schema.channel(jsonData, "y").key; + groupField = chartUtils.schema.channel(jsonData, "group").key; + } catch (error) { + console.error("数据列定义有误", error); + // 使用默认值防止出错 + dimensionField = dimensionField || "country"; + valueField = valueField || "value"; + groupField = groupField || "group"; + } + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + try { + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + if (dimensionChannel.unit) { + dimensionUnit = dimensionChannel.unit; + } + + if (valueChannel.unit) { + valueUnit = valueChannel.unit; + } + + if (groupChannel.unit) { + groupUnit = groupChannel.unit; + } + } catch (error) { + console.error("获取单位时出错", error); + } + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(null, dimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size + }).width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const textWidth = chartUtils.text.measure(null, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 结合维度标签和组标签最大宽度，重新计算margin.left + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 动态计算垂直空间分配 ---------- + + // 计算每个组内的维度数量 + const dimensionsPerGroup = {}; + let totalDimensions = 0; + + groups.forEach(group => { + // 过滤出该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + // 找出该组中所有唯一的维度 + const groupDimensions = [...new Set(groupData.map(d => d[dimensionField]))]; + // 保存该组的维度数量 + dimensionsPerGroup[group] = groupDimensions.length; + totalDimensions += groupDimensions.length; + }); + + // 设置组间固定间距和组标题空间 + const groupTitleHeight = 25; // 组标题高度 + const groupMargin = 20; // 组之间的固定间距 + + // 计算所有组间距的总和 + const totalGroupMargins = (groups.length - 1) * groupMargin; + + // 计算所有组标题的总高度 + const totalGroupTitlesHeight = groups.length * groupTitleHeight; + + // 计算条形的可用空间 = 总高度 - 所有组间距 - 所有组标题高度 + const availableBarSpace = innerHeight - totalGroupMargins - totalGroupTitlesHeight; + + // 计算单个条形的理想高度 + const idealBarHeight = availableBarSpace / totalDimensions; + + // 计算条形间距（为条形高度的一部分） + const barPadding = idealBarHeight * 0.2; // 条形间距为条形高度的30% + + // 准备保存每个组的位置和高度信息 + const groupPositions = {}; + let currentY = 0; + + // 为每个组计算起始位置和高度 + groups.forEach(group => { + const numDimensions = dimensionsPerGroup[group]; + + // 计算该组的总高度（组标题 + 所有条形高度 + 所有条形间距） + const totalBarSpacing = (numDimensions - 1) * barPadding; // 组内所有条形间距总和 + const totalBarsHeight = numDimensions * idealBarHeight; // 组内所有条形高度总和 + const groupHeight = groupTitleHeight + totalBarsHeight + totalBarSpacing; + + // 保存该组的位置信息 + groupPositions[group] = { + startY: currentY, + height: groupHeight, + barHeight: idealBarHeight, + barPadding: barPadding, + titleHeight: groupTitleHeight + }; + + // 更新当前Y位置（加上组高度和组间距） + currentY += groupHeight + groupMargin; + }); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 7.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 1.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.7 })); + }); + } + + // ---------- 8. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + return colorResolver.field(group, groups.indexOf(group), { palette: "tableau10" }).value; + } + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; // 默认颜色 + }; + + + // ---------- 11. 绘制图表 ---------- + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 获取该组的位置信息 + const groupPos = groupPositions[group]; + const groupStartY = groupPos.startY; + + // 创建组标签及其背景 + const groupLabelGroup = g.append("g") + .attr("transform", `translate(0, ${groupStartY + groupPos.titleHeight/2})`); + + const textSize = chartUtils.text.measure(groupLabelGroup, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }); + const textWidth = textSize.width; + const textHeight = textSize.height; + + // 为矩形添加内边距 + const rectPadding = { x: 4, y: 2 }; + const shadowOffset = { x: 3, y: 3 }; // 阴影偏移 + + // 创建矩形尺寸 + const rectX = -margin.left; + const rectY = -textHeight/2 - rectPadding.y; + const rectWidth = textWidth + rectPadding.x * 2 + 5; + const rectHeight = textHeight + rectPadding.y * 2; + const cornerRadius = rectPadding.y*2; + + // 创建一个右侧圆角矩形的路径 + const createRoundedRectPath = (x, y, width, height, radius) => { + return [ + `M ${x} ${y}`, // 从左上角开始 + `H ${x + width - radius}`, // 线到右上角减去圆角半径 + `Q ${x + width} ${y} ${x + width} ${y + radius}`, // 右上角圆角 + `V ${y + height - radius}`, // 线到右下角减去圆角半径 + `Q ${x + width} ${y + height} ${x + width - radius} ${y + height}`, // 右下角圆角 + `H ${x}`, // 线到左下角 + `V ${y}`, // 线到左上角 + 'Z' // 闭合路径 + ].join(' '); + }; + + // 创建阴影矩形 + const shadowPath = createRoundedRectPath( + rectX + shadowOffset.x, + rectY + shadowOffset.y, + rectWidth, + rectHeight, + cornerRadius + ); + + groupLabelGroup.append("path") + .attr("d", shadowPath) + .attr("fill", "#cccccc"); // 灰色阴影 + + // 创建主白色矩形 + const mainPath = createRoundedRectPath(rectX, rectY, rectWidth, rectHeight, cornerRadius); + + groupLabelGroup.append("path") + .attr("d", mainPath) + .attr("fill", "#ffffff"); // 白色背景 + + // 最后添加标签文本，使其位于顶层 + groupLabelGroup.append("text") + .attr("x", -margin.left + 6) // 文本位于左边距的10px处 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐文本 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", "#000000") // 黑色文本 + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + + // 对该组的维度进行排序 + const groupDimensions = [...new Set(groupData.map(d => d[dimensionField]))]; + + // 为每个维度绘制条形 + groupDimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置（考虑组标题高度、每个条形高度和条形间距） + const barY = groupStartY + groupPos.titleHeight + + dimIndex * (groupPos.barHeight + groupPos.barPadding); + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + groupPos.barHeight/2})`); + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", -5) // 左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.min(groupPos.barHeight * 0.9, parseFloat(typography.label.font_size))}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(dimension); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", groupPos.barHeight) // 使用为该组计算的条形高度 + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getGroupColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${Math.min(18, Math.max(groupPos.barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 检查文本是否适合条形的宽度（考虑内边距） + const padding = 3; // 每侧3px内边距 + + // 如果条形太窄，无法容纳文本，则放在条形外部 + if (barWidth < textWidth + padding) { + g.append("text") + .attr("x", barWidth + 5) // 条形右侧5像素处 + .attr("y", barY + groupPos.barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(groupPos.barHeight * 0.9, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } else { + // 文本适合放在条形内部 + g.append("text") + .attr("x", barWidth - 5) + .attr("y", barY + groupPos.barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(groupPos.barHeight * 0.9, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } + } + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..830e03a2c9794bdf3123e4da41dc8099bb07b9a6 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_03_hand.js @@ -0,0 +1,505 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_03_hand", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 8], [0, "inf"], [2, 6]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + let dimensionField = '', valueField = '', groupField = ''; + + try { + dimensionField = chartUtils.schema.channel(jsonData, "x").key; + valueField = chartUtils.schema.channel(jsonData, "y").key; + groupField = chartUtils.schema.channel(jsonData, "group").key; + } catch (error) { + console.error("数据列定义有误", error); + // 使用默认值防止出错 + dimensionField = dimensionField || "country"; + valueField = valueField || "value"; + groupField = groupField || "group"; + } + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + try { + const dimensionChannel = chartUtils.schema.channel(jsonData, "x"); + const valueChannel = chartUtils.schema.channel(jsonData, "y"); + const groupChannel = chartUtils.schema.channel(jsonData, "group"); + if (dimensionChannel.unit) { + dimensionUnit = dimensionChannel.unit; + } + + if (valueChannel.unit) { + valueUnit = valueChannel.unit; + } + + if (groupChannel.unit) { + groupUnit = groupChannel.unit; + } + } catch (error) { + console.error("获取单位时出错", error); + } + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(null, dimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size + }).width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const textWidth = chartUtils.text.measure(null, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 结合维度标签和组标签最大宽度，重新计算margin.left + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 动态计算垂直空间分配 ---------- + + // 计算每个组内的维度数量 + const dimensionsPerGroup = {}; + let totalDimensions = 0; + + groups.forEach(group => { + // 过滤出该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + // 找出该组中所有唯一的维度 + const groupDimensions = [...new Set(groupData.map(d => d[dimensionField]))]; + // 保存该组的维度数量 + dimensionsPerGroup[group] = groupDimensions.length; + totalDimensions += groupDimensions.length; + }); + + // 设置组间固定间距和组标题空间 + const groupTitleHeight = 25; // 组标题高度 + const groupMargin = 20; // 组之间的固定间距 + + // 计算所有组间距的总和 + const totalGroupMargins = (groups.length - 1) * groupMargin; + + // 计算所有组标题的总高度 + const totalGroupTitlesHeight = groups.length * groupTitleHeight; + + // 计算条形的可用空间 = 总高度 - 所有组间距 - 所有组标题高度 + const availableBarSpace = innerHeight - totalGroupMargins - totalGroupTitlesHeight; + + // 计算单个条形的理想高度 + const idealBarHeight = availableBarSpace / totalDimensions; + + // 计算条形间距（为条形高度的一部分） + const barPadding = idealBarHeight * 0.2; // 条形间距为条形高度的30% + + // 准备保存每个组的位置和高度信息 + const groupPositions = {}; + let currentY = 0; + + // 为每个组计算起始位置和高度 + groups.forEach(group => { + const numDimensions = dimensionsPerGroup[group]; + + // 计算该组的总高度（组标题 + 所有条形高度 + 所有条形间距） + const totalBarSpacing = (numDimensions - 1) * barPadding; // 组内所有条形间距总和 + const totalBarsHeight = numDimensions * idealBarHeight; // 组内所有条形高度总和 + const groupHeight = groupTitleHeight + totalBarsHeight + totalBarSpacing; + + // 保存该组的位置信息 + groupPositions[group] = { + startY: currentY, + height: groupHeight, + barHeight: idealBarHeight, + barPadding: barPadding, + titleHeight: groupTitleHeight + }; + + // 更新当前Y位置（加上组高度和组间距） + currentY += groupHeight + groupMargin; + }); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 7.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 1.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.7 })); + }); + } + + // ---------- 8. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + return colorResolver.field(group, groups.indexOf(group), { palette: "tableau10" }).value; + } + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; // 默认颜色 + }; + + + // ---------- 11. 绘制图表 ---------- + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 获取该组的位置信息 + const groupPos = groupPositions[group]; + const groupStartY = groupPos.startY; + + // 创建组标签及其背景 + const groupLabelGroup = g.append("g") + .attr("transform", `translate(0, ${groupStartY + groupPos.titleHeight/2})`); + + const textSize = chartUtils.text.measure(groupLabelGroup, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }); + const textWidth = textSize.width; + const textHeight = textSize.height; + + // 为矩形添加内边距 + const rectPadding = { x: 4, y: 2 }; + const shadowOffset = { x: 3, y: 3 }; // 阴影偏移 + + // 创建矩形尺寸 + const rectX = -margin.left; + const rectY = -textHeight/2 - rectPadding.y; + const rectWidth = textWidth + rectPadding.x * 2 + 5; + const rectHeight = textHeight + rectPadding.y * 2; + const cornerRadius = rectPadding.y*2; + + // 创建一个右侧圆角矩形的路径 + const createRoundedRectPath = (x, y, width, height, radius) => { + return [ + `M ${x} ${y}`, // 从左上角开始 + `H ${x + width - radius}`, // 线到右上角减去圆角半径 + `Q ${x + width} ${y} ${x + width} ${y + radius}`, // 右上角圆角 + `V ${y + height - radius}`, // 线到右下角减去圆角半径 + `Q ${x + width} ${y + height} ${x + width - radius} ${y + height}`, // 右下角圆角 + `H ${x}`, // 线到左下角 + `V ${y}`, // 线到左上角 + 'Z' // 闭合路径 + ].join(' '); + }; + + // 创建阴影矩形 + const shadowPath = createRoundedRectPath( + rectX + shadowOffset.x, + rectY + shadowOffset.y, + rectWidth, + rectHeight, + cornerRadius + ); + + groupLabelGroup.append("path") + .attr("d", shadowPath) + .attr("fill", "#cccccc"); // 灰色阴影 + + // 创建主白色矩形 + const mainPath = createRoundedRectPath(rectX, rectY, rectWidth, rectHeight, cornerRadius); + + groupLabelGroup.append("path") + .attr("d", mainPath) + .attr("fill", "#ffffff"); // 白色背景 + + // 最后添加标签文本，使其位于顶层 + groupLabelGroup.append("text") + .attr("x", -margin.left + 6) // 文本位于左边距的10px处 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐文本 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", "#000000") // 黑色文本 + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + + // 对该组的维度进行排序 + const groupDimensions = [...new Set(groupData.map(d => d[dimensionField]))]; + + // 为每个维度绘制条形 + groupDimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置（考虑组标题高度、每个条形高度和条形间距） + const barY = groupStartY + groupPos.titleHeight + + dimIndex * (groupPos.barHeight + groupPos.barPadding); + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + groupPos.barHeight/2})`); + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", -5) // 左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", `${Math.min(groupPos.barHeight * 0.9, parseFloat(typography.label.font_size))}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(dimension); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", groupPos.barHeight) // 使用为该组计算的条形高度 + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getGroupColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + const valueLabelFontSize = `${Math.min(18, Math.max(groupPos.barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 获取条形颜色 + const barColor = variables.has_gradient ? + getGroupColor(group) : // 渐变时使用基础颜色 + getGroupColor(group); + + // 始终将文本放在条形外部的尾端 + g.append("text") + .attr("x", barWidth + 5) // 条形右侧5像素处 + .attr("y", barY + groupPos.barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", barColor) // 使用与条形相同的颜色 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(groupPos.barHeight * 0.9, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } + }); + }); + + const roughness = 1; + const bowing = 1; + const fillStyle = "zigzag"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_04.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_04.js new file mode 100644 index 0000000000000000000000000000000000000000..e327471d6914c866ad37ad9fac7e82d1fbf25fcf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_04.js @@ -0,0 +1,435 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_04", + "is_composite": false, + "required_fields": ["x", "y", "group", "group2"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"], ["categorical"]], + "hierarchy":["group","group2"], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5], [2, 5]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "replace", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 水平分组条形图实现 - 使用D3.js //horizontal_grouped_bar_chart_05 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 40, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值和分组标签 + bottom: 30, // 底部边距 + left: 40 // 左侧空间减少，因为我们不显示维度文本，只显示图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + // 提取群组字段（默认取前两个group角色的列） + + const primaryGroupField = chartUtils.schema.channel(jsonData, "group").key; + const secondaryGroupField = chartUtils.schema.channel(jsonData, "group2").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const primaryGroups = [...new Set(chartData.map(d => d[primaryGroupField]))]; + const secondaryGroups = [...new Set(chartData.map(d => d[secondaryGroupField]))]; + + // 按主要分组和数值进行分组和排序 + const groupedData = {}; + primaryGroups.forEach(group => { + // 过滤属于此组的数据 + const groupItems = chartData.filter(d => d[primaryGroupField] === group); + + // 按数值降序排序 + const sortedItems = [...groupItems].sort((a, b) => +b[valueField] - +a[valueField]); + + groupedData[group] = sortedItems; + }); + + // ---------- 5. 计算标签宽度 ---------- + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 图标尺寸 + const flagWidth = 20; + const flagHeight = 15; + const flagPadding = 5; + const groupIconWidth = 20; + const groupIconHeight = 15; + const groupIconPadding = 5; + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 计算分组注释的最大宽度 + let maxGroupNoteWidth = 0; + primaryGroups.forEach(group => { + const textWidth = chartUtils.text.measure(tempSvg, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxGroupNoteWidth = Math.max(maxGroupNoteWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // 图标的总宽度 + const iconsWidth = flagWidth + flagPadding + groupIconWidth + groupIconPadding; + + // 根据图标尺寸调整左边距 + margin.left = Math.max(margin.left, iconsWidth + 40); + + + // ---------- 6. 计算分组布局 ---------- + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算合适的条形高度，确保所有条形在可用高度内可见 + // 计算总条形数量和组数 + let totalBars = 0; + primaryGroups.forEach(group => { + totalBars += groupedData[group].length; + }); + + const numGroups = primaryGroups.length; + + // 计算组间间距的总高度 + const groupPaddingRatio = 0.15; // 组间距占总高度的比例 + const groupPadding = innerHeight * groupPaddingRatio / (numGroups + 1); // 分配给每个组间距 + const totalGroupPadding = groupPadding * (numGroups - 1); + + // 计算可用于条形的总高度 + const availableForBars = innerHeight - totalGroupPadding; + + // 计算条形高度和条形间距 + const barPaddingRatio = variables.has_spacing ? 0.3 : 0.15; // 条形间距占条形高度的比例 + + // 计算理想的条形高度(包括间距) + const idealBarUnitHeight = availableForBars / totalBars; + + // 实际条形高度(不包括间距) + const barHeight = idealBarUnitHeight * (1 - barPaddingRatio); + const barPadding = idealBarUnitHeight * barPaddingRatio; + + // 计算每组的高度和偏移量 + const groupHeights = {}; + const groupOffsets = {}; + + let currentOffset = margin.top; + primaryGroups.forEach(group => { + const itemCount = groupedData[group].length; + // 计算当前组的总高度（包括所有条形和条形间距） + const groupHeight = itemCount * barHeight + (itemCount - 1) * barPadding; + + groupHeights[group] = groupHeight; + groupOffsets[group] = currentOffset; + + // 更新下一组的起始位置 + currentOffset += groupHeight + groupPadding; + }); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用定义的高度，不进行自动调整 + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 为每个主要分组添加渐变（如果启用） + if (variables.has_gradient) { + primaryGroups.forEach(group => { + const groupColor = colorResolver.field(group, 0, { fallbackKey: "primary", fallback: "#3ca951" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group.replace(/\s+/g, '-').replace(/[^a-zA-Z0-9-]/g, '')}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 8. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, 0)`); + + // ---------- 10. 渲染每个分组 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary", fallback: "#3ca951" }).value; + }; + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + // 在条形左侧添加灰色竖线 + g.append("line") + .attr("x1", 0) + .attr("y1", margin.top) + .attr("x2", 0) + .attr("y2", height - margin.bottom) + .attr("stroke", "#cccccc") + .attr("stroke-width", 3); + // 遍历每个主要分组，添加背景矩形 + primaryGroups.forEach(group => { + const groupData = groupedData[group]; + const groupOffset = groupOffsets[group]; + const groupHeight = groupHeights[group]; + const barColor = getBarColor(group); + + // 添加组背景矩形（使用组颜色的浅色调） + if (groupData.length > 0) { + const bgColor = colorResolver.variant(barColor, { mode: "brighter", amount: 1.5 }); + bgColor.opacity = 0.2; // 设置半透明 + + g.append("rect") + .attr("x", 0) // 背景矩形从bar左边缘开始 + .attr("y", groupOffset) + .attr("width", innerWidth + margin.right) // 宽度调整为内部宽度加右边距 + .attr("height", groupHeight) + .attr("fill", bgColor) + .attr("class","background") + .attr("rx", variables.has_rounded_corners ? 5 : 0) + .attr("ry", variables.has_rounded_corners ? 5 : 0); + } + + // 添加分组注释 + if (groupData.length > 0) { + const lastItemIndex = groupData.length - 1; + const lastItemY = groupOffset + lastItemIndex * (barHeight + barPadding) + barHeight / 2; + + g.append("text") + .attr("x", width - margin.left - 10) + .attr("y", lastItemY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) // 使用label字体 + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + + .text(group); + } + + // 为组中的每个项目绘制条形和标签 + groupData.forEach((dataPoint, index) => { + // 计算条形的y坐标，考虑到条形间距 + const yPos = groupOffset + index * (barHeight + barPadding); + const barWidth = xScale(+dataPoint[valueField]); + + + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", yPos) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#bar-gradient-${group.replace(/\s+/g, '-').replace(/[^a-zA-Z0-9-]/g, '')})` : + barColor) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 提取维度和次要分组值 + const dimension = dataPoint[dimensionField]; + const secondaryGroup = dataPoint[secondaryGroupField]; + + // 添加国家/维度图标 + const flagX = -flagWidth - flagPadding - groupIconWidth - groupIconPadding; + const flagY = yPos + (barHeight - flagHeight) / 2; + + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", flagY) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加次要分组图标（如发展状态） + const groupIconX = flagX + flagWidth + flagPadding; + const groupIconY = yPos + (barHeight - groupIconHeight) / 2; + + if (images.field && images.field[secondaryGroup]) { + g.append("image") + .attr("x", groupIconX) + .attr("y", groupIconY) + .attr("width", groupIconWidth) + .attr("height", groupIconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[secondaryGroup]); + } + + // 不再添加维度文本标签，只显示图标 + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", yPos + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${barHeight * 0.7}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .text(formattedValue); + }); + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05.js new file mode 100644 index 0000000000000000000000000000000000000000..c579a6b547b8d3f5853cfa7846456bd0639c57d3 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05.js @@ -0,0 +1,584 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_05", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_split_bar_chart_06 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对数据进行排序，使用原始顺序 + + // ---------- 5. 智能换行布局计算 ---------- + + // 初始计算内部绘图区域尺寸 + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + const barPadding = variables.has_spacing ? 0.3 : 0.1; + const yScaleInitial = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + const barHeight = yScaleInitial.bandwidth(); + + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagPadding = 5; + + const targetFontSize = parseFloat(typography.label.font_size) || 12; + const lineSpacing = 1.01; + const labelMaxWidth = Math.max(80, width * 0.15); + const labelMaxHeight = barHeight; + + const { dimLabelConfig, maxLabelWidth } = buildDimLabelLayout({ + containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: labelMaxWidth, + maxHeight: labelMaxHeight, + lineSpacing, + targetFontSize + }); + + margin.left = Math.max(margin.left, iconSize.width + flagPadding + maxLabelWidth + 20); + + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + tempSvg.remove(); + + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach((group, i) => { + // 为每个组创建一个渐变 + const groupColor = colorResolver.field(group, i, { palette: "category10" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField])]) + .range([0, innerWidth]); + + // 颜色比例尺（用于组） + const colorScale = colorResolver.scale(groups, { palette: "category10" }); + chartUtils.legend.centered(svg, groups, { + colorScale, + colorResolver, + colors, + }, width / 2, margin.top / 2, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 10, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 获取描边颜色的辅助函数 ---------- + + const getStrokeColor = (color) => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.variant(color, { mode: "darker", amount: 0.5 }); + }; + + // ---------- 12. 为每个维度绘制分组条形 ---------- + + dimensions.forEach(dimension => { + // 获取此维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const flagHeight = iconSize.height; + const flagWidth = iconSize.width; + const flagX = -flagWidth - flagPadding; + const labelY = yScale(dimension) + barHeight / 2; + + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", labelY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + const labelConfig = dimLabelConfig[dimension]; + if (!labelConfig) { + g.append("text") + .attr("x", flagX - 5) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + } else { + const centerY = labelY; + const labelGroup = g.append("text") + .attr("x", flagX - 5) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", flagX - 5) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + } + + // 计算每个组的条形高度 + const groupBarHeight = barHeight / groups.length; + + // 绘制每个组的条形 + groups.forEach((group, groupIndex) => { + // 找到此维度和此组的数据点 + const dataPoint = dimensionData.find(d => d[groupField] === group); + + if (dataPoint) { + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 计算垂直位置 - 这里是关键修改，确保条形不重叠 + const groupY = yScale(dimension) + (groupIndex * groupBarHeight); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", groupY) + .attr("width", barWidth) + .attr("height", groupBarHeight) + .attr("fill", variables.has_gradient ? + `url(#bar-gradient-${groupIndex})` : + colorScale(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? + getStrokeColor(colorScale(group)) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", groupY + groupBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(groupBarHeight * 0.6, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..45aee2b4c627210a59e8f76d22f46c645589b500 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_05_hand.js @@ -0,0 +1,580 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_05_hand", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_split_bar_chart_06 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对数据进行排序，使用原始顺序 + + // ---------- 5. 布局计算和字体调整 ---------- + + const dimLabelMaxWidth = width * 0.2; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScale.bandwidth(); + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: barHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算icon尺寸 + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + const flagPadding = 5; + + // 根据标签宽度和icon宽度调整左边距 + margin.left = flagWidth + flagPadding + maxLabelWidth + 15; + + // 计算图例项宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + tempSvg.remove(); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach((group, i) => { + // 为每个组创建一个渐变 + const groupColor = colorResolver.field(group, i, { palette: "category10" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField])]) + .range([0, innerWidth]); + + // 颜色比例尺（用于组） + const colorScale = colorResolver.scale(groups, { palette: "category10" }); + chartUtils.legend.centered(svg, groups, { + colorScale, + colorResolver, + colors, + }, width / 2, margin.top / 2, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 10, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 获取描边颜色的辅助函数 ---------- + + const getStrokeColor = (color) => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.variant(color, { mode: "darker", amount: 0.5 }); + }; + + // ---------- 12. 为每个维度绘制分组条形 ---------- + + dimensions.forEach(dimension => { + // 获取此维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const flagX = -flagWidth - flagPadding - 5; + const centerY = yScale(dimension) + barHeight / 2; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", flagX - 5) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", flagX - 5) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 计算每个组的条形高度 + const groupBarHeight = barHeight / groups.length; + + // 绘制每个组的条形 + groups.forEach((group, groupIndex) => { + // 找到此维度和此组的数据点 + const dataPoint = dimensionData.find(d => d[groupField] === group); + + if (dataPoint) { + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 计算垂直位置 - 这里是关键修改，确保条形不重叠 + const groupY = yScale(dimension) + (groupIndex * groupBarHeight); + + // 绘制条形 + g.append("rect") + .attr("x", 0) + .attr("y", groupY) + .attr("width", barWidth) + .attr("height", groupBarHeight) + .attr("fill", variables.has_gradient ? + `url(#bar-gradient-${groupIndex})` : + colorScale(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? + getStrokeColor(colorScale(group)) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", groupY + groupBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(groupBarHeight * 0.6, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + } + }); + + const roughness = 1; + const bowing = 1; + const fillStyle = "zigzag"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_06.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_06.js new file mode 100644 index 0000000000000000000000000000000000000000..958b60ec19ad847d4510991f97b3ea9ed0eebfab --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_06.js @@ -0,0 +1,345 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_06", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_split_bar_chart_06 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对数据进行排序，使用原始顺序 + + // ---------- 5. 计算标签宽度 ---------- + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 初始填充值（会根据barHeight动态调整） + // const flagPadding = 5; // 不再需要图标填充 + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = textWidth; // 只考虑文本宽度 + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整左边距（添加一些边距） + margin.left = Math.max(margin.left, maxLabelWidth + 20); + margin.right = Math.max(margin.right, maxValueWidth + 20); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 创建斜线纹理模式 + const patternDensity = 6; // 固定斜线密度 + const patternStrokeWidth = 1.5; // 固定斜线宽度 + groups.forEach((group, i) => { + // 为每个组获取颜色 + const groupColor = colorResolver.field(group, i, { palette: "category10" }).value; + + // 创建斜线纹理模式 + const patternId = `pattern-${group.replace(/\s+/g, '-')}-${i}`; // 确保 ID 唯一 + const pattern = defs.append("pattern") + .attr("id", patternId) + .attr("patternUnits", "userSpaceOnUse") + .attr("width", patternDensity) // 使用固定值 + .attr("height", patternDensity) // 使用固定值 + .attr("patternTransform", "rotate(45)"); + + // 添加背景矩形 + pattern.append("rect") + .attr("width", patternDensity) // 使用固定值 + .attr("height", patternDensity) // 使用固定值 + .attr("fill", groupColor) + .attr("opacity", 0.8); + + // 添加斜线 + pattern.append("line") + .attr("x1", 0) + .attr("y1", 0) + .attr("x2", patternDensity) + .attr("y2", patternDensity) + .attr("stroke", "white") + .attr("stroke-width", patternStrokeWidth) + .attr("opacity", 0.6); + }); + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距 - 使用固定值 + const barPadding = 0.1; // 设置固定边距 + + // Y轴比例尺（用于维度）- 使用原始顺序 + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField])]) + .range([0, innerWidth]); + + // 颜色比例尺（用于组） + const colorScale = colorResolver.scale(groups, { palette: "category10" }); + chartUtils.legend.centered(svg, groups, { + colorScale, + colorResolver, + colors, + }, width / 2, margin.top / 2, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: legendPadding, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 12. 为每个维度绘制分组条形 ---------- + + dimensions.forEach(dimension => { + // 获取此维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const barHeight = yScale.bandwidth(); + + + const labelY = yScale(dimension) + barHeight / 2; + + // 添加维度标签 + g.append("text") + // .attr("x", flagX - 5) // 旧的基于图标位置的 X 坐标 + .attr("x", -10) // 设置新的 X 坐标，例如在 Y 轴左侧 10px 处 + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 计算每个组的条形高度 + const groupBarHeight = barHeight / groups.length; + + // 固定圆角半径 + const cornerRadius = 3; + + // 绘制每个组的条形 + groups.forEach((group, groupIndex) => { + // 找到此维度和此组的数据点 + const dataPoint = dimensionData.find(d => d[groupField] === group); + + if (dataPoint) { + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 计算垂直位置 - 这里是关键修改，确保条形不重叠 + const groupY = yScale(dimension) + (groupIndex * groupBarHeight); + + // 绘制条形 - 使用 path 实现右侧圆角 + let pathData; + // 仅在条形足够宽和高时应用圆角 + if (barWidth >= cornerRadius && groupBarHeight >= 2 * cornerRadius) { + pathData = ` + M 0,${groupY} + L ${barWidth - cornerRadius},${groupY} + A ${cornerRadius},${cornerRadius} 0 0 1 ${barWidth},${groupY + cornerRadius} + L ${barWidth},${groupY + groupBarHeight - cornerRadius} + A ${cornerRadius},${cornerRadius} 0 0 1 ${barWidth - cornerRadius},${groupY + groupBarHeight} + L 0,${groupY + groupBarHeight} + Z + `; + } else { + // 对于太窄或太矮的条形，绘制普通矩形 + pathData = ` + M 0,${groupY} + L ${barWidth},${groupY} + L ${barWidth},${groupY + groupBarHeight} + L 0,${groupY + groupBarHeight} + Z + `; + } + + const bar = g.append("path") // 使用 path 替代 rect + .attr("d", pathData) + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + + + // 应用填充：始终使用纹理 + const patternIdBar = `pattern-${group.replace(/\s+/g, '-')}-${groupIndex}`; + bar.attr("fill", `url(#${patternIdBar})`); + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", groupY + groupBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(groupBarHeight * 0.5, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_07.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_07.js new file mode 100644 index 0000000000000000000000000000000000000000..f94e90d638061462ab0e7bb2e640f327f871df1f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_07.js @@ -0,0 +1,679 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_07", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [5,7]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js - 胶囊数量表示数值 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 - 圆角始终启用 + // variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; + variables.has_gradient = variables.has_gradient !== undefined ? variables.has_gradient : false; // 虽然不用渐变填充，但保留效果选项 + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : true; // 胶囊间需要间距 + + // 数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 - 右侧需要重新计算 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 初始右侧边距，稍后调整 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理与值缩放 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 找出最大值，以确定胶囊数量 + const overallMax = d3.max(chartData, d => Math.abs(+d[valueField])) || 0; + + // 胶囊数量计算 + const maxCapsules = 30; // 每组最多显示30个胶囊 + // 计算每个胶囊代表的数值（处理 overallMax 为 0 的情况） + const valuePerCapsule = overallMax > 0 ? Math.ceil(overallMax / maxCapsules) : 1; + + // 计算值到胶囊数量的映射函数 + const valueToCapsules = (value) => { + if (valuePerCapsule === 0) return 0; // 避免除以零 + return Math.min(maxCapsules, Math.ceil(Math.abs(value) / valuePerCapsule)); + }; + + // ---------- 5. 智能换行布局计算 ---------- + + // 初始计算内部绘图区域尺寸 + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + const barPadding = variables.has_spacing ? 0.3 : 0.1; + const yScaleInitial = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + const barHeight = yScaleInitial.bandwidth(); + + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagPadding = 5; + + const targetFontSize = parseFloat(typography.label.font_size) || 12; + const lineSpacing = 1.01; + const labelMaxWidth = Math.max(80, width * 0.15); + const labelMaxHeight = barHeight; + + const { dimLabelConfig, maxLabelWidth } = buildDimLabelLayout({ + containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: labelMaxWidth, + maxHeight: labelMaxHeight, + lineSpacing, + targetFontSize + }); + + margin.left = Math.max(margin.left, iconSize.width + flagPadding + maxLabelWidth + 20); + + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 图标和胶囊尺寸配置 + const iconSizeRatio = 0.6; // 图标高度占维度带宽的比例 + const maxIconSize = 25; // 图标最大尺寸 + const iconPadding = 5; // 图标和标签/胶囊之间的间距 + const capsuleWidth = 5; // 单个胶囊宽度 + const capsuleSpacing = 2; // 胶囊之间的间距 + + // 计算最大维度标签宽度 + let maxDimLabelWidth = 0; + dimensions.forEach(dimension => { + const formattedDimension = dimensionUnit ? `${dimension}${dimensionUnit}` : `${dimension}`; + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxDimLabelWidth = Math.max(maxDimLabelWidth, textWidth); + }); + + // 计算最大数值标签宽度 (基于最大可能值和单位) + let maxValueLabelWidth = 0; + const maxPossibleValue = overallMax; + const formattedMaxValue = valueUnit ? `${maxPossibleValue}${valueUnit}` : `${maxPossibleValue}`; + maxValueLabelWidth = chartUtils.text.measure(tempSvg, formattedMaxValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + // 计算图例项宽度和总宽度 + const legendItemWidths = []; + let totalLegendWidth = 0; + const legendPadding = 15; // 图例项之间的间距 (增加间距) + const legendCapsuleWidth = 12; // 图例胶囊宽度 + const legendCapsuleHeight = 8; // 图例胶囊高度 + const legendTextPadding = 5; // 图例胶囊和文本之间的间距 + + groups.forEach(group => { + const textWidth = chartUtils.text.measure(tempSvg, group, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + // 图例项宽度 = 胶囊宽度 + 间距 + 文本宽度 + 右侧间距 + const legendItemWidth = legendCapsuleWidth + legendTextPadding + textWidth + legendPadding; + legendItemWidths.push(legendItemWidth); + totalLegendWidth += legendItemWidth; + }); + + // 删除临时SVG + tempSvg.remove(); + + // 重新计算左边距以包含图标 + // 左边距 = 最大标签宽度 + 标签与图标间距 + 图标最大宽度 + 图标与条形图间距 + const labelIconPadding = 5; // 标签和图标之间的间距 + const iconBarPadding = 10; // 图标和条形图开始位置的间距 + margin.left = Math.max(margin.left, maxDimLabelWidth + labelIconPadding + maxIconSize + iconBarPadding); + + // 计算所需的最大右侧宽度 (保持不变) + const maxCapsulesWidth = maxCapsules * (capsuleWidth + capsuleSpacing); + const requiredRightWidth = maxCapsulesWidth + maxValueLabelWidth + 10; // 10px 额外间距 + margin.right = Math.max(margin.right, requiredRightWidth); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器与效果 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 (保留阴影和纹理) + const defs = svg.append("defs"); + + const getColor = (group) => { + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + } + + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 创建斜线纹理模式 (包含渐变背景) + const patternDensity = 6; // 固定斜线密度 + const patternStrokeWidth = 1.5; // 固定斜线宽度 + groups.forEach((group, i) => { + const groupColor = getColor(group); + const patternId = `pattern-${group.replace(/[^a-zA-Z0-9]/g, '-')}-${i}`; // 基于 group 生成 ID + const gradientId = `pattern-gradient-${group.replace(/[^a-zA-Z0-9]/g, '-')}-${i}`; // 渐变 ID + + // 1. 定义 pattern 内使用的渐变 + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%").attr("y1", "0%") + .attr("x2", "100%").attr("y2", "0%"); // 水平从左到右 + + // 渐变颜色：从深到亮 + gradient.append("stop").attr("offset", "0%").attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.7 })); + gradient.append("stop").attr("offset", "100%").attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 1.2 })); + + // 2. 定义 pattern + const pattern = defs.append("pattern") + .attr("id", patternId) + .attr("patternUnits", "userSpaceOnUse") + .attr("width", patternDensity) + .attr("height", patternDensity) + .attr("patternTransform", "rotate(45)"); + + // 3. 在 pattern 内添加使用上面定义的渐变的背景矩形 + pattern.append("rect") + .attr("width", patternDensity) + .attr("height", patternDensity) + .attr("fill", `url(#${gradientId})`); // 使用 pattern 内的渐变填充 + + // 4. 在 pattern 内添加白色斜线 (覆盖在渐变背景上) + pattern.append("line") + .attr("x1", 0).attr("y1", 0).attr("x2", 0).attr("y2", patternDensity) + .attr("stroke", "white").attr("stroke-width", patternStrokeWidth).attr("opacity", 0.6); + }); + + // ---------- 7. 创建比例尺 ---------- + + // Y轴比例尺（用于维度）- 使用原始顺序 + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(0.3); // 维度组之间的间距 + chartUtils.legend.draw(svg, groups, { + color: (group, index) => `url(#pattern-${group.replace(/[^a-zA-Z0-9]/g, '-')}-${index})`, + colorResolver, + colors, + }, { + y: margin.top * 0.7, + maxWidth: width - 100, + align: "center", + markerShape: "capsule", + markerWidth: 15, + markerHeight: 10, + labelGap: legendTextPadding, + itemGap: legendItemPadding, + rowGap: legendVerticalSpacing || 10, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 获取描边颜色（如果启用描边） + const getStrokeColor = (barColor) => { + return variables.has_stroke ? colorResolver.variant(barColor, { mode: "darker", amount: 0.5 }) : "none"; + }; + + // ---------- 10. 为每个维度绘制分组胶囊 ---------- + + dimensions.forEach(dimension => { + // 获取此维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const dimensionY = yScale(dimension); + const dimensionBandwidth = yScale.bandwidth(); + + // 计算每个组的胶囊行高度 (考虑组间间距) + const groupSpacingRatio = 0.1; // 组间距占行高的比例 + const numGroups = groups.length; + const totalSpacingHeight = dimensionBandwidth * groupSpacingRatio * (numGroups > 1 ? numGroups - 1 : 0); + const availableGroupHeight = dimensionBandwidth - totalSpacingHeight; + const groupCapsuleHeight = availableGroupHeight / numGroups; + const finalCapsuleHeight = Math.max(4, groupCapsuleHeight); // 最小高度 4px + const groupSpacing = dimensionBandwidth * groupSpacingRatio; // 实际间距像素值 + + // 计算图标尺寸和位置 + const iconSize = Math.min(maxIconSize, dimensionBandwidth * iconSizeRatio); + const iconY = dimensionY + (dimensionBandwidth - iconSize) / 2; // 图标垂直居中 + const iconAvailable = images.field && images.field[dimension]; + + // --- Corrected Icon and Label Positioning --- + let finalLabelX; + const labelCenterY = dimensionY + dimensionBandwidth / 2; + + if (iconAvailable) { + // Position icon just left of the bar area (x=0) + const iconX = -iconBarPadding - iconSize; + // Position label left of the icon + finalLabelX = iconX - labelIconPadding; + + // 添加维度图标 + g.append("image") + .attr("x", iconX) + .attr("y", iconY) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio", "xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } else { + // Position label just left of the bar area (x=0) + finalLabelX = -iconBarPadding; + } + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + if (!labelConfig) { + g.append("text") + .attr("x", finalLabelX) + .attr("y", labelCenterY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + } else { + const centerY = labelCenterY; + const labelGroup = g.append("text") + .attr("x", finalLabelX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", finalLabelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + } + + // --- End of Corrected Positioning --- + + // 绘制每个组的胶囊 + groups.forEach((group, groupIndex) => { + const dataPoint = dimensionData.find(d => d[groupField] === group); + + if (dataPoint) { + const value = +dataPoint[valueField]; + const capsuleCount = valueToCapsules(value); + + // 计算当前组胶囊的垂直起始位置 (包含组间距) + const groupY = dimensionY + (groupIndex * (finalCapsuleHeight + groupSpacing)); + + // 绘制胶囊 + for (let j = 0; j < capsuleCount; j++) { + const capsuleX = j * (capsuleWidth + capsuleSpacing); + + g.append("rect") + .attr("x", capsuleX) + .attr("y", groupY) + .attr("width", capsuleWidth) + .attr("height", finalCapsuleHeight) + // 应用包含渐变的纹理填充 + .attr("fill", `url(#pattern-${group.replace(/[^a-zA-Z0-9]/g, '-')}-${groupIndex})`) + // 圆角 + .attr("rx", capsuleWidth / 2) + .attr("ry", capsuleWidth / 2) // 使用宽度的一半确保胶囊状 + .style("stroke", getStrokeColor(getColor(group))) + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + } + + // 添加数值标签 + const formattedValue = valueUnit ? `${chartUtils.format.autoText(value)}${valueUnit}` : `${chartUtils.format.autoText(value)}`; + // 定位在最后一个胶囊之后 + const lastCapsuleEnd = capsuleCount * (capsuleWidth + capsuleSpacing) - capsuleSpacing; // 最后一个胶囊的结束X坐标 (如果 count > 0) + const labelX = (capsuleCount > 0 ? lastCapsuleEnd : 0) + 5; // 如果没有胶囊，标签从0开始，否则从最后一个胶囊后5px开始 + + g.append("text") + .attr("x", labelX) + .attr("y", groupY + finalCapsuleHeight / 2) // 垂直居中于胶囊行 + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(finalCapsuleHeight * 0.5, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..1eed1b8b8df2c7abee434aa5b61a11cb4f00e62c --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_10.js @@ -0,0 +1,379 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_10", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js //horizontal_grouped_bar_chart_05 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值格式化函数 + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 40, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值和分组标签 + bottom: 30, // 底部边距 + left: 40 // 左侧空间减少，因为我们不显示维度文本，只显示图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + const primaryGroupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const primaryGroups = [...new Set(chartData.map(d => d[primaryGroupField]))]; + + // 按主要分组和数值进行分组和排序 + const groupedData = {}; + primaryGroups.forEach(group => { + // 过滤属于此组的数据 + const groupItems = chartData.filter(d => d[primaryGroupField] === group); + + // 按数值降序排序 + const sortedItems = [...groupItems].sort((a, b) => +b[valueField] - +a[valueField]); + + groupedData[group] = sortedItems; + }); + + // ---------- 5. 计算标签宽度 ---------- + + // 图标尺寸 + const flagWidth = 20; + const flagHeight = 15; + const flagPadding = 5; + const labelMeasureOptions = { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }; + const annotationMeasureOptions = { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }; + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+d[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(null, formattedValue, annotationMeasureOptions).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // *** BEGIN ADDITION: Calculate Max Dimension Label Width *** + let maxDimensionLabelWidth = 0; + dimensions.forEach(dimension => { + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, labelMeasureOptions).width; + maxDimensionLabelWidth = Math.max(maxDimensionLabelWidth, textWidth); + }); + // *** END ADDITION *** + + // 计算分组注释的最大宽度 + let maxGroupNoteWidth = 0; + primaryGroups.forEach(group => { + const textWidth = chartUtils.text.measure(null, group, labelMeasureOptions).width; + + maxGroupNoteWidth = Math.max(maxGroupNoteWidth, textWidth); + }); + + // ** MODIFY ** 根据图标和最大标签尺寸调整左边距 + const baseLeftPadding = 10; // Base padding to the left of the labels + margin.left = maxDimensionLabelWidth + flagPadding + flagWidth + flagPadding + baseLeftPadding; + + + // ---------- 6. 计算分组布局 ---------- + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算合适的条形高度，确保所有条形在可用高度内可见 + // 计算总条形数量和组数 + let totalBars = 0; + primaryGroups.forEach(group => { + totalBars += groupedData[group].length; + }); + + const numGroups = primaryGroups.length; + + // 计算组间间距的总高度 + const groupPaddingRatio = 0.15; // 组间距占总高度的比例 + const groupPadding = innerHeight * groupPaddingRatio / (numGroups + 1); // 分配给每个组间距 + const totalGroupPadding = groupPadding * (numGroups - 1); + + // 计算可用于条形的总高度 + const availableForBars = innerHeight - totalGroupPadding; + + // 计算条形高度和条形间距 + const barPaddingRatio = 0.15; // Use fixed padding ratio, remove spacing effect logic + + // 计算理想的条形高度(包括间距) + const idealBarUnitHeight = availableForBars / totalBars; + + // 初始计算实际条形高度(不包括间距) + let calculatedBarHeight = idealBarUnitHeight * (1 - barPaddingRatio); + + // 限制最大条形高度 + const barHeight = Math.min(calculatedBarHeight, 40); + + // 根据最终的条形高度计算条形间距，以保持总单元高度 + const barPadding = idealBarUnitHeight - barHeight; + + // 计算每组的高度和偏移量 + const groupHeights = {}; + const groupOffsets = {}; + + let currentOffset = margin.top; + primaryGroups.forEach(group => { + const itemCount = groupedData[group].length; + // 计算当前组的总高度（包括所有条形和条形间距） + const groupHeight = itemCount * barHeight + (itemCount - 1) * barPadding; + + groupHeights[group] = groupHeight; + groupOffsets[group] = currentOffset; + + // 更新下一组的起始位置 + currentOffset += groupHeight + groupPadding; + }); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用定义的高度，不进行自动调整 + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 8. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, 0)`); + + // ---------- 10. 渲染每个分组 ---------- + + // 获取条形颜色的辅助函数 + const getBarColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary", fallback: "#3ca951" }).value; + }; + + // 在条形左侧添加灰色竖线 + g.append("line") + .attr("x1", 0) + .attr("y1", margin.top) + .attr("x2", 0) + .attr("y2", height - margin.bottom) + .attr("stroke", "#cccccc") + .attr("stroke-width", 3); + // 遍历每个主要分组，添加背景矩形 + primaryGroups.forEach(group => { + const groupData = groupedData[group]; + const groupOffset = groupOffsets[group]; + const groupHeight = groupHeights[group]; + const barColor = getBarColor(group); + + // 添加分组注释 + if (groupData.length > 0) { + const lastItemIndex = groupData.length - 1; + const lastItemY = groupOffset + lastItemIndex * (barHeight + barPadding) + barHeight / 2; + + g.append("text") + .attr("x", width - margin.left - 10) + .attr("y", lastItemY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) // 使用label字体 + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + + .text(group); + } + + // 为组中的每个项目绘制条形和标签 + groupData.forEach((dataPoint, index) => { + // 计算条形的y坐标，考虑到条形间距 + const yPos = groupOffset + index * (barHeight + barPadding); + const barWidth = xScale(+dataPoint[valueField]); + + // Draw the bar using a simple rect element + g.append("rect") // Revert back to rect + .attr("x", 0) + .attr("y", yPos) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", barColor) // Use solid bar color + .attr("rx", barHeight/6) + .attr("ry", barHeight/6) + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 提取维度 + const dimension = dataPoint[dimensionField]; + + // 添加国家/维度图标 (Positioned left of bar) + const flagX = -flagWidth - flagPadding; // Icon right edge at -flagPadding + const flagY = yPos + (barHeight - flagHeight) / 2; + + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", flagY) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // *** BEGIN ADDITION: Add Dimension Label (Left of Icon, Right Aligned) *** + const labelX = flagX - flagPadding; // Label right edge next to icon's left edge + const labelY = yPos + barHeight / 2; // Vertically centered with bar + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + g.append("text") + .attr("class", "dimension-label") + .attr("x", labelX) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // Right align text + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .text(formattedDimension); + // *** END ADDITION *** + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + // --- BEGIN MODIFICATION: Conditional Label Placement --- + const valueLabelFontSize = `${barHeight * 0.7}px`; + const textWidth = chartUtils.text.measure(g, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + const labelPadding = 10; // Padding for inside label (5px each side) + + // Decide label position and color + let valueLabelX, valueLabelAnchor, valueLabelFill; + if (textWidth + labelPadding < barWidth) { + // Place inside, centered, white + valueLabelX = barWidth / 2; + valueLabelAnchor = "middle"; + valueLabelFill = "white"; + } else { + // Place outside, right, default color + valueLabelX = barWidth + 5; + valueLabelAnchor = "start"; + valueLabelFill = colorResolver.text({ fallback: "#000000" }).value; + } + + // Create the actual value label with calculated properties + g.append("text") + .attr("x", valueLabelX) + .attr("y", yPos + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${barHeight * 0.7}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(formattedValue); + // --- END MODIFICATION --- + }); + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_11.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_11.js new file mode 100644 index 0000000000000000000000000000000000000000..28e0211f3a699f0865a8601d7fb010e25ecf819d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_11.js @@ -0,0 +1,579 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_11", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["gradient"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js //horizontal_grouped_bar_chart_05 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 清空容器 + d3.select(containerSelector).html(""); + + // 数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 40, // 顶部留出标题空间 + right: 60, // 右侧足够显示数值和分组标签 + bottom: 30, // 底部边距 + left: 40 // 左侧空间减少，因为我们不显示维度文本，只显示图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + + const primaryGroupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const primaryGroups = [...new Set(chartData.map(d => d[primaryGroupField]))]; + + // 按主要分组和数值进行分组和排序 + const groupedData = {}; + primaryGroups.forEach(group => { + // 过滤属于此组的数据 + const groupItems = chartData.filter(d => d[primaryGroupField] === group); + + // 按数值降序排序 + const sortedItems = [...groupItems].sort((a, b) => +b[valueField] - +a[valueField]); + + groupedData[group] = sortedItems; + }); + + // ---------- 5. 计算分组布局 ---------- + + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + // 计算合适的条形高度，确保所有条形在可用高度内可见 + // 计算总条形数量和组数 + let totalBars = 0; + primaryGroups.forEach(group => { + totalBars += groupedData[group].length; + }); + + const numGroups = primaryGroups.length; + + // 计算组间间距的总高度 + const groupPaddingRatio = 0.15; // 组间距占总高度的比例 + const groupPadding = innerHeight * groupPaddingRatio / (numGroups + 1); // 分配给每个组间距 + const totalGroupPadding = groupPadding * (numGroups - 1); + + // 计算可用于条形的总高度 + const availableForBars = innerHeight - totalGroupPadding; + + // 计算条形高度和条形间距 + const barPaddingRatio = 0.15; // Use fixed padding ratio, remove spacing effect logic + + // 计算理想的条形高度(包括间距) + const idealBarUnitHeight = availableForBars / totalBars; + + // 实际条形高度(不包括间距) + const barHeight = idealBarUnitHeight * (1 - barPaddingRatio); + const barPadding = idealBarUnitHeight * barPaddingRatio; + + // icon尺寸（按barHeight动态） + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + const flagPadding = 5; + + // 智能换行布局计算 + const targetFontSize = parseFloat(typography.label.font_size) || 12; + const lineSpacing = 1.01; + const labelMaxWidth = Math.max(80, width * 0.2); + const labelMaxHeight = barHeight; + + const { dimLabelConfig, maxLabelWidth } = buildDimLabelLayout({ + containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: labelMaxWidth, + maxHeight: labelMaxHeight, + lineSpacing, + targetFontSize + }); + + // 根据标签宽度更新左边距 + margin.left = Math.max(margin.left, maxLabelWidth + flagWidth + flagPadding * 2 + 10); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // 计算每组的高度和偏移量 + const groupHeights = {}; + const groupOffsets = {}; + + let currentOffset = margin.top; + primaryGroups.forEach(group => { + const itemCount = groupedData[group].length; + // 计算当前组的总高度（包括所有条形和条形间距） + const groupHeight = itemCount * barHeight + (itemCount - 1) * barPadding; + + groupHeights[group] = groupHeight; + groupOffsets[group] = currentOffset; + + // 更新下一组的起始位置 + currentOffset += groupHeight + groupPadding; + }); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) // 使用定义的高度，不进行自动调整 + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // --- BEGIN Gradient Definitions --- + const defs = svg.append("defs"); + + // Moved getBarColor definition here (Needed for gradient definition) + const getBarColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary", fallback: "#3ca951" }).value; + }; + + primaryGroups.forEach(group => { + const groupColor = getBarColor(group); + const gradientId = `bar-gradient-${group.replace(/\s+/g, '-').replace(/[^a-zA-Z0-9-]/g, '')}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") // Horizontal gradient + .attr("y2", "0%"); + + // 3-stop gradient: dark -> bright -> dark + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 1.5 })); // Adjusted brightness a bit from 2.5 + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + // --- END Gradient Definitions --- + + // --- BEGIN LEGEND CREATION --- + chartUtils.legend.centered(svg, primaryGroups, { + color: group => getBarColor(group), + colorResolver, + colors, + }, width / 2, 15 / 2 + 80, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 20, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + + // ---------- 8. 创建比例尺 ---------- + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) * 1.05]) // 添加5%边距 + .range([0, innerWidth]); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); // Adjust group transform for new margin + + // ---------- 10. 渲染每个分组 ---------- + + // 遍历每个主要分组，添加背景矩形 + primaryGroups.forEach(group => { + const groupData = groupedData[group]; + const groupOffset = groupOffsets[group]; + const groupHeight = groupHeights[group]; + const barColor = getBarColor(group); + + // 为组中的每个项目绘制条形和标签 + groupData.forEach((dataPoint, index) => { + // 计算条形的y坐标，考虑到条形间距 + const yPos = groupOffset + index * (barHeight + barPadding); + const barWidth = xScale(+dataPoint[valueField]); + + // Draw the bar using a simple rect element + g.append("rect") // Revert back to rect + .attr("x", 0) + .attr("y", yPos) + .attr("width", barWidth) + .attr("height", barHeight) + // Apply gradient fill + .attr("fill", `url(#bar-gradient-${group.replace(/\s+/g, '-').replace(/[^a-zA-Z0-9-]/g, '')})`) + .attr("rx", barHeight/6) + .attr("ry", barHeight/6) + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 提取维度 + const dimension = dataPoint[dimensionField]; + + // 添加国家/维度图标 (Positioned left of bar) + const flagX = -flagWidth - flagPadding; // Icon right edge at -flagPadding + const flagY = yPos + (barHeight - flagHeight) / 2; + + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", flagY) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签（支持多行） + const labelX = flagX - flagPadding; + const labelY = yPos + barHeight / 2; + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const labelConfig = dimLabelConfig[dimension]; + if (!labelConfig) { + g.append("text") + .attr("class", "dimension-label") + .attr("x", labelX) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value) + .text(formattedDimension); + } else { + const centerY = labelY; + const labelGroup = g.append("text") + .attr("class", "dimension-label") + .attr("x", labelX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#000000" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", labelX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + } + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + + // --- BEGIN MODIFICATION: Force Label Outside --- + + const valueLabelX = barWidth + 5; + const valueLabelAnchor = "start"; + const valueLabelFill = colorResolver.text({ fallback: "#000000" }).value; + + // Create the actual value label with fixed properties + g.append("text") + .attr("x", valueLabelX) + .attr("y", yPos + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", valueLabelAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", `${barHeight * 0.7}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", valueLabelFill) + .text(formattedValue); + // --- END MODIFICATION --- + }); + }); + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..dab92bca1fa2b546b239e3cc5b007dfdce8d6f0f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_12.js @@ -0,0 +1,571 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_12", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 6]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "styled", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_grouped_bar_chart_01 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "'Comic Sans MS', cursive", font_size: "18px", font_weight: "bold" }, + label: { font_family: "'Comic Sans MS', cursive", font_size: "12px", font_weight: "normal" }, + description: { font_family: "'Comic Sans MS', cursive", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "'Comic Sans MS', cursive", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + let height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 80; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 动态调整高度：如果x维度数量超过15，每增加一个维度，高度增加3% + if (dimensions.length > 15) { + const extraDimensions = dimensions.length - 15; + const heightIncreaseFactor = 1 + (extraDimensions * 0.03); // 增加比例因子 + height = Math.round(height * heightIncreaseFactor); // 应用高度调整 + } + + // ---------- 5. 计算标签和图标空间 ---------- + + // 创建临时SVG用于测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(tempSvg, dimension, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: typography.label.font_size + }).width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const textWidth = chartUtils.text.measure(tempSvg, group, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: typography.label.font_size, + fontWeight: "bold" + }).width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 删除临时SVG + tempSvg.remove(); + + // === 修改点：结合维度标签和组标签最大宽度，重新计算margin.left === + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const sketchPadding = 5; // 背景内边距 + const dimensionLabelWidth = maxLabelWidth + 2 * sketchPadding + 20; // 标签宽度 + 背景padding + 额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // *** 修改: 移除间距相关的计算 *** + // const groupPadding = innerHeight * (variables.has_spacing ? 0.08 : 0.06); // 移除组间距 + const groupHeight = innerHeight / groups.length; // 每组的原始高度 + + // *** 修改: 移除间距对barHeight的影响 *** + // const barHeight = (groupHeight - groupPadding) / dimensions.length; + const barHeight = groupHeight / dimensions.length; // 维度在组内均分高度 + // const actualBarHeight = variables.has_spacing ? barHeight * 0.65 : barHeight * 0.75; // 移除间距影响 + const actualBarHeight = barHeight * 0.75; // 固定条形实际高度比例 + + // 标志尺寸 + const iconWidth = actualBarHeight * 0.9; + const iconHeight = iconWidth; + const iconRightPadding = iconWidth * 0.4; // 图标右侧到柱子的间距 + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // --- Sketch Pattern for Left Bars (or even index groups) --- + const patternLeft = defs.append("pattern") + .attr("id", "pattern-sketch-left") + .attr("width", 8) + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + + patternLeft.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", "#4269d0"); // 使用一个基色，具体颜色会被覆盖 + + patternLeft.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 0.8); + + // --- Sketch Pattern for Right Bars (or odd index groups) --- + const patternRight = defs.append("pattern") + .attr("id", "pattern-sketch-right") + .attr("width", 8) + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(-45)"); // 反向旋转 + + patternRight.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", "#ff725c"); // 使用另一个基色 + + patternRight.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 0.8); + + // --- Sketch Pattern for Label Backgrounds --- + const patternLabelSketch = defs.append("pattern") + .attr("id", "pattern-label-sketch") + .attr("width", 8) + .attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + + patternLabelSketch.append("rect") + .attr("width", 8) + .attr("height", 8) + .attr("fill", "#FFFFFF"); + + patternLabelSketch.append("path") + .attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0") + .attr("stroke", "#CCCCCC") + .attr("stroke-width", 0.6); + + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + + // 如果有可用颜色数组，按索引使用 + const groupIndex = groups.indexOf(group); + const availableColor = colorResolver.available(groupIndex, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + + // Provide default fallback colors if none are defined + const defaultColors = ["#4269d0", "#ff725c", "#4CAF50", "#FFC107", "#9C27B0", "#795548"]; + return defaultColors[groupIndex % defaultColors.length]; + } + + // 获取描边颜色 + const getStrokeColor = () => { + return "#555"; // 固定手绘描边颜色 + }; + + // *** 添加: 计算字体大小的函数 (从 vertical_group_bar_chart_13 复制) *** + const calculateFontSize = (text, maxWidth, baseSize = 12) => { + const avgCharWidth = baseSize * 0.6; + const textWidth = text.length * avgCharWidth; + if (textWidth < maxWidth) { + return baseSize; + } + return Math.max(8, Math.floor(baseSize * (maxWidth / textWidth))); // 最小字体8px + }; + + // ========== 9. 添加交替行背景（新增） ========== + if (jsonData.variation?.background === "styled") { + // 每个 group 下有若干维度，故在每个 group 里为维度的"行"画背景 + groups.forEach((group, groupIndex) => { + const groupStartY = groupIndex * groupHeight; + dimensions.forEach((dimension, dimIndex) => { + // 偶数行添加背景 + if (dimIndex % 2 === 0) { + g.append("rect") + .attr("x", 0) + .attr("y", groupStartY + dimIndex * barHeight) + .attr("width", innerWidth) + .attr("height", barHeight) + .attr("class","background") + .attr("fill", "#f0f0f0") // 稍微调整背景色 + .attr("opacity", 0.7); // 稍微调整透明度 + } + }); + }); + } + + // ---------- 10. 绘制图表 ---------- + + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 计算该组的垂直位置 + const groupStartY = groupIndex * (groupHeight); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + + // *** 添加: 确定该组使用的手绘图案 *** + const barPatternId = groupIndex % 2 === 0 ? "url(#pattern-sketch-left)" : "url(#pattern-sketch-right)"; + // *** 添加: 获取组的实际颜色，用于图案背景 (可选，如果需要动态颜色图案) *** + const groupBaseColor = getGroupColor(group); + // *** 可选: 更新对应 pattern 的 rect fill (如果需要动态颜色) *** + // d3.select(`#${barPatternId.slice(5, -1)} rect`).attr("fill", groupBaseColor); + + // 为每个维度绘制条形 + dimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置 + const barY = groupStartY + dimIndex * barHeight; + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + actualBarHeight / 2})`); + + // 绘制图标 + if (images.field && images.field[dimension]) { + // 图标位置：紧贴条形左侧 + labelGroup.append("image") + .attr("x", -iconWidth - iconRightPadding) + .attr("y", -iconHeight/2) + .attr("width", iconWidth) + .attr("height", iconHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // *** 修改: 绘制带手绘背景的维度标签 *** + const dimensionTextContent = dimension; + const dimensionLabelX = -iconWidth - iconRightPadding - 15; // 文本右边缘 X 坐标 + const dimensionBaseFontSize = parseFloat(typography.label.font_size); + + // 修改：限制文本最大高度为条形高度的80%，确保文本更小 + const dimensionMaxTextHeight = actualBarHeight * 0.8; + const dimensionFontSize = Math.min(dimensionBaseFontSize, dimensionMaxTextHeight); + + const dimBBox = chartUtils.text.measure(labelGroup, dimensionTextContent, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: `${dimensionFontSize}px`, + fontWeight: typography.label.font_weight + }); + + // 3. 计算背景尺寸和位置 - 确保背景高度不超过条形高度 + const dimBgWidth = dimBBox.width + 2 * sketchPadding; + + + const dimBgHeight = Math.min( + dimBBox.height + sketchPadding, // 减小内边距 + actualBarHeight * 0.9 // + ); + + const dimBgX = dimensionLabelX - dimBBox.width - sketchPadding; // 背景左上角X + + // 修改：垂直居中背景 + const dimBgY = -dimBgHeight / 2; // 确保背景垂直居中 + + // 4. 绘制背景 (在文本之前插入) + labelGroup.insert("rect", ":first-child") // 插入为第一个子元素 + .attr("x", dimBgX) + .attr("y", dimBgY) + .attr("width", dimBgWidth) + .attr("height", dimBgHeight) + .attr("fill", "url(#pattern-label-sketch)") + .attr("stroke", "#AAAAAA") + .attr("stroke-width", 0.5); + + // 5. 绘制最终文本 (在背景之上) + labelGroup.append("text") + .attr("class", "dimension-label") + .attr("x", dimensionLabelX) + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", "'Comic Sans MS', cursive") // *** 强制字体 *** + .style("font-size", `${dimensionFontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .text(dimensionTextContent); + + // *** 修改: 绘制条形，使用手绘图案和描边 *** + g.append("rect") + .attr("class", `bar group-${groupIndex}`) + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", actualBarHeight) + .attr("fill", barPatternId) // 应用手绘图案 + .attr("rx", 5) // *** 强制圆角 *** + .attr("ry", 5) // *** 强制圆角 *** + .style("stroke", variables.has_stroke ? getStrokeColor() : "none") // 应用手绘描边 + .style("stroke-width", variables.has_stroke ? 1 : 0) // 固定描边宽度 + // .style("filter", variables.has_shadow ? "url(#shadow)" : "none") // *** 移除阴影应用 *** + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // *** 修改: 绘制带手绘背景的数值标签 *** + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(+dataPoint[valueField])}${valueUnit}` : + `${chartUtils.format.autoText(+dataPoint[valueField])}`; + const valueLabelBaseFontSize = Math.min(parseFloat(typography.annotation.font_size), actualBarHeight * 0.55); // 基础字体大小 + + // -- 创建一个组来容纳标签和背景 -- + const valueLabelGroup = g.append("g") + .attr("class", "value-label-group"); + + const valueBBox = chartUtils.text.measure(valueLabelGroup, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: `${valueLabelBaseFontSize}px`, + fontWeight: "bold" + }); + + // 3. 计算背景尺寸和位置 (相对于组的0,0) - 用于居中 + const valueBgWidth = valueBBox.width + 2 * sketchPadding; + const valueBgHeight = valueBBox.height + 1.5 * sketchPadding; + // *** 修改: 背景定位改为相对中心 (0,0) *** + const valueBgX = -valueBgWidth / 2; + const valueBgY = -valueBgHeight / 2; + + // 4. 绘制背景 + valueLabelGroup.append("rect") + .attr("class", "value-label-background") + .attr("x", valueBgX) + .attr("y", valueBgY) + .attr("width", valueBgWidth) + .attr("height", valueBgHeight) + .attr("fill", "url(#pattern-label-sketch)") + .attr("stroke", "#AAAAAA") + .attr("stroke-width", 0.5); + + // 5. 绘制最终文本 (在组内居中) + valueLabelGroup.append("text") + .attr("class", "value-label") + .attr("x", 0) // *** 文本X居中 *** + .attr("y", 0) // *** 文本Y基线调整 *** + .attr("dy", "0em") // 配合 dominant-baseline + .attr("text-anchor", "middle") // *** 文本水平居中 *** + .attr("dominant-baseline", "middle") // *** 文本垂直居中 *** + .style("fill", colorResolver.text({ fallback: "#333" }).value) + .style("font-family", "'Comic Sans MS', cursive") // *** 强制字体 *** + .style("font-size", `${valueLabelBaseFontSize}px`) + .style("font-weight", "bold") + .style("pointer-events", "none") + .text(formattedValue); + + // 6. 定位整个组 (调整X坐标以考虑背景宽度) + // const valueLabelGroupX = barWidth + 8; // 旧的起始X + const valueLabelGroupX = barWidth + 8 + valueBgWidth / 2; // *** 调整组X位置，使其中心在 bar 右侧 8px 处 *** + const valueLabelGroupY = barY + actualBarHeight / 2; // 组的Y位置：条形垂直中心 + valueLabelGroup.attr("transform", `translate(${valueLabelGroupX}, ${valueLabelGroupY})`); + } + }); + }); + + // *** 添加: wrapText 辅助函数 (如果尚未存在，需要从 vertical_group_bar_chart_13 复制或确保可用) *** + // (假设 wrapText 函数已存在或已添加) + function wrapText(text, str, width, lineHeight) { + const words = str.split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); // 获取原始 y + const x = text.attr("x"); // 获取原始 x + const dy = parseFloat(text.attr("dy") || 0); // 获取原始 dy + + text.text(null); // 清空现有文本 + + let tspans = []; + + // 优先按单词换行 + if (words.length > 1 && words.some(w => w.length > 0)) { // Check for actual words + let currentLine = []; + while (word = words.pop()) { + currentLine.push(word); + const isOverflow = chartUtils.text.measure(null, currentLine.join(" "), { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 1) { + currentLine.pop(); + tspans.push(currentLine.join(" ")); + currentLine = [word]; + lineNumber++; + } + } + if (currentLine.length > 0) { + tspans.push(currentLine.join(" ")); + } + } else { // 按字符换行 + const chars = str.split(''); + let currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const nextLine = currentLine + chars[i]; + const isOverflow = chartUtils.text.measure(null, nextLine, { + fontFamily: text.style("font-family"), + fontSize: parseFloat(text.style("font-size")), + fontWeight: text.style("font-weight") + }).width > width; + + if (isOverflow && currentLine.length > 0) { + tspans.push(currentLine); + currentLine = chars[i]; + lineNumber++; + } else { + currentLine = nextLine; + } + } + if (currentLine.length > 0) { + tspans.push(currentLine); + } + } + + const totalLines = tspans.length; + // 调整垂直居中: 向上移动半行 * (总行数 - 1) + // dominant-baseline="hanging" 时，第一个 tspan 的 y 决定顶部位置 + // dy 用于后续行的偏移 + const firstLineYAdjust = - (totalLines - 1) / 2 * lineHeight; + + tspans.forEach((lineText, i) => { + text.append("tspan") + .attr("x", x) // 保持原始 x + .attr("dy", (i === 0 ? firstLineYAdjust + dy : lineHeight) + "em") // 第一行调整基线，后续行应用行高 + .text(lineText); + }); + } + + const equalGroupRectWidth = Math.min(innerWidth / groups.length, width * 0.8 / groups.length); + chartUtils.legend.labeledStrip(svg, groups.map((group, index) => ({ + label: group, + fill: index % 2 === 0 ? "url(#pattern-sketch-left)" : "url(#pattern-sketch-right)", + })), { + centerWidth: width, + y: height - margin.bottom + 20, + itemWidth: equalGroupRectWidth, + showNumber: true, + labelFontFamily: "'Comic Sans MS', cursive", + numberFontFamily: "'Comic Sans MS', cursive", + labelFontSize: 12, + textColor: colorResolver.text({ fallback: "#333333" }).value, + wrapLabel: (node, label, w) => wrapText(node, label, w, 1.1), + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_13.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_13.js new file mode 100644 index 0000000000000000000000000000000000000000..caf12d590b78247fa9dd988f584d2c6c1c1fefee --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_13.js @@ -0,0 +1,252 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_13", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js horizontal_split_bar_chart_06 (Applying Sketch Style) +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "'Comic Sans MS', cursive", font_size: "18px", font_weight: "bold" }, + label: { font_family: "'Comic Sans MS', cursive", font_size: "12px", font_weight: "normal" }, + description: { font_family: "'Comic Sans MS', cursive", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "'Comic Sans MS', cursive", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : true; // Default stroke to true for sketch + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，会动态调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对数据进行排序，使用原始顺序 + + // ---------- 5. 计算标签宽度 (使用手绘字体) ---------- + // *** 添加: 手绘背景内边距 *** + const sketchPadding = 5; + + // 创建临时SVG来测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: "'Comic Sans MS', cursive", + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + // *** 修改: 考虑背景padding *** + const totalWidth = textWidth + 2 * sketchPadding; // 文本宽度 + 背景padding + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + // *** 修改: 考虑背景padding *** + maxValueWidth = Math.max(maxValueWidth, textWidth + 2 * sketchPadding); + }); + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整左边距（添加一些边距） + margin.left = Math.max(margin.left, maxLabelWidth + 15); // 增加右侧空间 + // 根据数值标签宽度调整右边距 (添加一些边距) + margin.right = Math.max(margin.right, maxValueWidth + 15); + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // *** 修改: 使用来自 vertical_group_bar_chart_13 的手绘图案定义 *** + // --- Sketch Pattern Definitions --- + const patternLeft = defs.append("pattern") + .attr("id", "pattern-sketch-left") + .attr("width", 8).attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + patternLeft.append("rect").attr("width", 8).attr("height", 8).attr("fill", "#4269d0"); // Default color + patternLeft.append("path").attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0").attr("stroke", "#FFFFFF").attr("stroke-width", 0.8); + + const patternRight = defs.append("pattern") + .attr("id", "pattern-sketch-right") + .attr("width", 8).attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(-45)"); + patternRight.append("rect").attr("width", 8).attr("height", 8).attr("fill", "#ff725c"); // Default color + patternRight.append("path").attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0").attr("stroke", "#FFFFFF").attr("stroke-width", 0.8); + + const patternLabelSketch = defs.append("pattern") + .attr("id", "pattern-label-sketch") + .attr("width", 8).attr("height", 8) + .attr("patternUnits", "userSpaceOnUse") + .attr("patternTransform", "rotate(45)"); + patternLabelSketch.append("rect").attr("width", 8).attr("height", 8).attr("fill", "#FFFFFF"); + patternLabelSketch.append("path").attr("d", "M -1,2 l 10,0 M -1,5 l 10,0 M -1,8 l 10,0").attr("stroke", "#CCCCCC").attr("stroke-width", 0.6); + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距 - 使用固定值 + const barPadding = 0.1; + + // Y轴比例尺（用于维度）- 使用原始顺序 + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField]) || 1]) // Ensure domain starts at 0 and handles empty data + .range([0, innerWidth]); + + // 获取组颜色 - 用于动态更新图案背景色 (可选) + function getGroupColor(group) { + // 优先使用指定颜色 + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + // 如果有可用颜色数组，按索引使用 + const groupIndex = groups.indexOf(group); + const availableColor = colorResolver.available(groupIndex, { cycle: true, usePalette: false }).value; + if (availableColor) return availableColor; + const primaryColor = colorResolver.other("primary").value; + if (primaryColor) { + // 可以基于 group 索引生成不同深浅的 primary 颜色 + // 简单的亮度调整示例 + const factor = 1 - (groupIndex * 0.15); // 索引越大越暗 + return chartUtils.color.variant( + chartUtils.color.variant(primaryColor, { mode: "brighter", amount: factor * 0.5 }), + { mode: "darker", amount: factor * 0.2 } + ); // 示例调整 + } + // 提供默认 fallback 颜色 + const defaultColors = ["#4269d0", "#ff725c", "#4CAF50", "#FFC107", "#9C27B0"]; + return defaultColors[groupIndex % defaultColors.length]; + } + + const equalGroupRectWidth = Math.min(innerWidth / groups.length, width * 0.8 / groups.length); + chartUtils.legend.labeledStrip(svg, groups.map(group => ({ + label: group, + fill: getGroupColor(group), + })), { + centerWidth: width, + y: height - margin.bottom + 20, + itemWidth: equalGroupRectWidth, + labelFontFamily: typography.annotation.font_family, + numberFontFamily: typography.label.font_family, + labelFontSize: 12, + textColor: colorResolver.text({ fallback: "#333333" }).value, + wrapLabel: (node, label, w) => wrapText(node, label, w, 1.1), + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_15.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_15.js new file mode 100644 index 0000000000000000000000000000000000000000..6ca0ada59d6cf66293e07626d213c2979cd8be79 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_bar_chart_15.js @@ -0,0 +1,593 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Bar Chart", + "chart_name": "horizontal_group_bar_chart_15", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js Horizontal Grouped Bar Chart plain chart#2 圆角 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 数值格式化函数 + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 100, // 顶部留出标题空间 + right: 30, // 右侧足够显示数值 + bottom: 60, // 底部边距 + left: 60 // 左侧初始空间，用于维度标签和图标 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 不对数据进行排序，使用原始顺序 + + // ---------- 5. 智能换行布局计算 ---------- + + // 初始计算内部绘图区域尺寸 + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + const barPadding = variables.has_spacing ? 0.3 : 0.1; + const yScaleInitial = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + const barHeight = yScaleInitial.bandwidth(); + + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagPadding = 5; + + const targetFontSize = parseFloat(typography.label.font_size) || 12; + const lineSpacing = 1.01; + const labelMaxWidth = Math.max(80, width * 0.2); + const labelMaxHeight = barHeight; + + const { dimLabelConfig, maxLabelWidth } = buildDimLabelLayout({ + containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: labelMaxWidth, + maxHeight: labelMaxHeight, + lineSpacing, + targetFontSize + }); + + margin.left = Math.max(margin.left, iconSize.width + flagPadding + maxLabelWidth + 20); + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // 水平条形图右侧半圆路径生成函数 + function createRightSemicirclePath(x, y, barWidth, barHeight, radius) { + // x, y: bar的左上角坐标 + // barWidth: bar的宽度 + // barHeight: bar的高度 + // radius: 半圆的半径 (通常是 barHeight / 2) + + if (barWidth <= 1e-9) return ""; // 避免绘制零宽度或负宽度段 + + if (barWidth >= radius) { + // 宽度足以容纳一个矩形部分和一个完整的半圆 + const rectPartWidth = barWidth - radius; + return `M${x},${y}` + // 移动到左上角 + `L${x + rectPartWidth},${y}` + // 画到矩形部分的右上角 + `A${radius},${radius} 0 0,1 ${x + rectPartWidth},${y + barHeight}` + // 画右侧半圆弧 + `L${x},${y + barHeight}` + // 画到底部左边 + `Z`; // 关闭路径 + } else { + // barWidth < radius. 条形太窄，无法形成完整的半圆。 + // 右端将是一个椭圆弧。x方向的"半径"是barWidth，y方向的"半径"是radius (barHeight / 2)。 + const arcRx = barWidth; + const arcRy = radius; // 等于 barHeight / 2 + + // 画一个向右凸出的椭圆弧，从左上角到左下角，最右端到达 x + barWidth + return `M${x},${y}` + // 从左上角开始 + `A${arcRx},${arcRy} 0 1,1 ${x},${y + barHeight}` + // 画大弧，向右凸出 + `Z`; // 关闭路径 + } + } + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach((group, i) => { + // 为每个组创建一个渐变 + const groupColor = colorResolver.field(group, i, { palette: "category10" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(groupColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // Y轴比例尺（用于维度）- 使用原始顺序 + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[valueField])]) + .range([0, innerWidth]); + + // 颜色比例尺（用于组） + const colorScale = colorResolver.scale(groups, { palette: "category10" }); + chartUtils.legend.centered(svg, groups, { + colorScale, + colorResolver, + colors, + }, width / 2, margin.top / 2, { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 20, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? 2 : 0, + }); + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 10. 获取描边颜色的辅助函数 ---------- + + const getStrokeColor = (color) => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.variant(color, { mode: "darker", amount: 0.5 }); + }; + + // ---------- 12. 为每个维度绘制分组条形 ---------- + + dimensions.forEach(dimension => { + // 获取此维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const barHeight = yScale.bandwidth(); + + // 使用calcIconSize计算的icon尺寸 + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + const flagX = -flagWidth - flagPadding - 5; + const labelY = yScale(dimension) + barHeight / 2; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", labelY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + if (!labelConfig) { + g.append("text") + .attr("x", flagX - 5) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + } else { + const centerY = labelY; + const labelGroup = g.append("text") + .attr("x", flagX - 5) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", flagX - 5) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + } + + // 计算每个组的条形高度 + const groupBarHeight = barHeight / groups.length; + + // 绘制每个组的条形 + groups.forEach((group, groupIndex) => { + // 找到此维度和此组的数据点 + const dataPoint = dimensionData.find(d => d[groupField] === group); + + if (dataPoint) { + const value = +dataPoint[valueField]; + const barWidth = xScale(value); + + // 计算垂直位置 - 这里是关键修改，确保条形不重叠 + const groupY = yScale(dimension) + (groupIndex * groupBarHeight); + + // 绘制条形 + g.append("path") + .attr("d", createRightSemicirclePath(0, groupY, barWidth, groupBarHeight, groupBarHeight / 2)) + .attr("fill", variables.has_gradient ? + `url(#bar-gradient-${groupIndex})` : + colorScale(group)) + .style("stroke", variables.has_stroke ? + getStrokeColor(colorScale(group)) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none") + .on("mouseover", function() { + d3.select(this).attr("opacity", 0.8); + }) + .on("mouseout", function() { + d3.select(this).attr("opacity", 1); + }); + + // 添加数值标签 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(value)}${valueUnit}` : + `${chartUtils.format.autoText(value)}`; + + g.append("text") + .attr("x", barWidth + 5) + .attr("y", groupY + groupBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.max(groupBarHeight * 0.6, parseFloat(typography.annotation.font_size))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + } + }); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..e8cab54438fea0966e2b222c46b1157a83076b4e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js @@ -0,0 +1,342 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Group Dot Bar Chart", + "chart_name": "horizontal_group_dot_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 6], [0, 100], [2, 5]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 数值格式化函数 + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, yScale.bandwidth()]) + .padding(0.05); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([0, chartWidth]) + .nice(); + + // 确定标签的最大长度： + let minYLabelRatio = 1.0; + const maxYLabelWidth = yScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // y label + const yLabelText = String(d[yField]); + let currentWidth = chartUtils.text.measure(null, yLabelText).width; + if (currentWidth > maxYLabelWidth) { + minYLabelRatio = Math.min(minYLabelRatio, maxYLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 添加defs用于定义裁剪路径 + const defs = svg.append("defs"); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .remove(); + + // 添加X轴 + /* + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (xUnit ? ` ${xUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + */ + + // 为每个分类创建条形组 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(0,${yScale(d.category)})`); + + // 计算每个柱子的配置参数 + const maxValue = d3.max(chartData, d => +d[yField]); + + // 设置点状图标的默认参数 + const defaultBarWidth = 30; // 默认图标宽度 + const defaultBarSpacing = 5; // 默认图标间距 + const largerGroupSpacing = 10; // 每组图标间的额外间距 + + // 每组的图标数量 + const groupSize = 5; + + // 添加维度标签（分类名称） + barGroups.append("text") + .attr("x", -10) + .attr("y", yScale.bandwidth() / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => d.category); + + // 为每个分组依次绘制点图 + groups.forEach(group => { + barGroups.each(function(d) { + const rowY = groupScale(group); // 当前分组在Y轴的位置 + const rowHeight = groupScale.bandwidth(); // 分组高度 + const value = d.groups[group] || 0; // 获取值，如果不存在则为0 + + // 计算要显示多少个完整图标 + const barCount = Math.floor(value / maxValue * 20); // 将值映射到 0-20 个图标（根据需要调整） + const partialBar = (value / maxValue * 20) - barCount; // 计算小数部分 + + // 计算图标大小（根据分组宽度调整） + const barHeight = rowHeight * 0.8; // 图标高度为行高的80% + const barWidth = barHeight; // 图标宽度等于高度，保持比例 + const barY = rowY + (rowHeight - barHeight) / 2; // 垂直居中 + + // 计算图标间距 + const barSpacing = Math.min(defaultBarSpacing, barWidth * 0.2); + + // 绘制完整图标 + for (let i = 0; i < barCount; i++) { + // 计算当前图标所在的组 + const groupIndex = Math.floor(i / groupSize); + // 计算在当前组内的索引 + const inGroupIndex = i % groupSize; + + // 计算X位置（考虑组间的额外间距） + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 绘制单个图标 + d3.select(this) + .append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("xlink:href", jsonData.images.field[group]); + } + + // 如果有小数部分，绘制部分宽度的最后一个图标 + if (partialBar > 0) { + const groupIndex = Math.floor(barCount / groupSize); + const inGroupIndex = barCount % groupSize; + + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 使用SVG裁剪路径实现部分图标显示 + const imageWidth = barWidth * partialBar; + + // 创建唯一的裁剪路径ID（使用分类名称和分组名称确保唯一性） + const clipPathId = `clip-path-${d.category.replace(/\s+/g, '-')}-${group.replace(/\s+/g, '-')}-${barCount}`; + + // 在defs中定义裁剪路径 + defs.append("clipPath") + .attr("id", clipPathId) + .attr("clipPathUnits", "userSpaceOnUse") // 使用用户坐标系而非对象坐标系 + .append("rect") + .attr("x", barX) // 使用与图像相同的x坐标 + .attr("y", barY) // 使用与图像相同的y坐标 + .attr("width", imageWidth) + .attr("height", barHeight); + + // 使用裁剪路径显示部分图标 + d3.select(this) + .append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) // 使用完整宽度 + .attr("height", barHeight) + .attr("clip-path", `url(#${clipPathId})`) + .attr("xlink:href", jsonData.images.field[group]); + } + + // 计算最后一个图标的位置，用于放置数值标签 + const lastGroupIndex = Math.floor(barCount / groupSize); + const lastInGroupIndex = barCount % groupSize; + let lastBarX = (lastGroupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (lastInGroupIndex * (barWidth + barSpacing)); + + // 如果有小数部分，调整标签位置 + if (partialBar > 0) { + lastBarX += barWidth * partialBar; + } else if (barCount > 0) { + lastBarX += barWidth; + } + + // 添加数值标签 + d3.select(this) + .append("text") + .attr("x", lastBarX + 15) + .attr("y", barY + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(chartUtils.format.autoText(value) + (yUnit ? ` ${yUnit}` : '')); + }); + }); + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..a0db3eb38b16a4d9b33c8b2d8c848619d2e91d61 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_dot_bar_chart_0.js.bug @@ -0,0 +1,350 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Group Dot Bar Chart", + "chart_name": "horizontal_group_dot_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 6], [0, 100], [2, 5]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.2); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, yScale.bandwidth()]) + .padding(0.05); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([0, chartWidth]) + .nice(); + + // 确定标签的最大长度： + let minYLabelRatio = 1.0; + const maxYLabelWidth = yScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // y label + const yLabelText = String(d[yField]); + let currentWidth = getTextWidth(yLabelText); + if (currentWidth > maxYLabelWidth) { + minYLabelRatio = Math.min(minYLabelRatio, maxYLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 添加defs用于定义裁剪路径 + const defs = svg.append("defs"); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .remove(); + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => d + (xUnit ? ` ${xUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + + // 为每个分类创建条形组 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(0,${yScale(d.category)})`); + + // 计算每个柱子的配置参数 + const maxValue = d3.max(chartData, d => +d[yField]); + + // 设置点状图标的默认参数 + const defaultBarWidth = 30; // 默认图标宽度 + const defaultBarSpacing = 5; // 默认图标间距 + const largerGroupSpacing = 10; // 每组图标间的额外间距 + + // 每组的图标数量 + const groupSize = 5; + + // 添加维度标签（分类名称） + barGroups.append("text") + .attr("x", -10) + .attr("y", yScale.bandwidth() / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colors.text_color) + .text(d => d.category); + + // 为每个分组依次绘制点图 + groups.forEach(group => { + barGroups.each(function(d) { + const rowY = groupScale(group); // 当前分组在Y轴的位置 + const rowHeight = groupScale.bandwidth(); // 分组高度 + const value = d.groups[group] || 0; // 获取值，如果不存在则为0 + + // 计算要显示多少个完整图标 + const barCount = Math.floor(value / maxValue * 20); // 将值映射到 0-20 个图标（根据需要调整） + const partialBar = (value / maxValue * 20) - barCount; // 计算小数部分 + + // 计算图标大小（根据分组宽度调整） + const barHeight = rowHeight * 0.8; // 图标高度为行高的80% + const barWidth = barHeight; // 图标宽度等于高度，保持比例 + const barY = rowY + (rowHeight - barHeight) / 2; // 垂直居中 + + // 计算图标间距 + const barSpacing = Math.min(defaultBarSpacing, barWidth * 0.2); + + // 绘制完整图标 + for (let i = 0; i < barCount; i++) { + // 计算当前图标所在的组 + const groupIndex = Math.floor(i / groupSize); + // 计算在当前组内的索引 + const inGroupIndex = i % groupSize; + + // 计算X位置（考虑组间的额外间距） + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 绘制单个图标 + d3.select(this) + .append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("xlink:href", jsonData.images.field[group]); + } + + // 如果有小数部分，绘制部分宽度的最后一个图标 + if (partialBar > 0) { + const groupIndex = Math.floor(barCount / groupSize); + const inGroupIndex = barCount % groupSize; + + const barX = (groupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (inGroupIndex * (barWidth + barSpacing)); + + // 使用SVG裁剪路径实现部分图标显示 + const imageWidth = barWidth * partialBar; + + // 创建唯一的裁剪路径ID（使用分类名称和分组名称确保唯一性） + const clipPathId = `clip-path-${d.category.replace(/\s+/g, '-')}-${group.replace(/\s+/g, '-')}-${barCount}`; + + // 在defs中定义裁剪路径 + defs.append("clipPath") + .attr("id", clipPathId) + .attr("clipPathUnits", "userSpaceOnUse") // 使用用户坐标系而非对象坐标系 + .append("rect") + .attr("x", barX) // 使用与图像相同的x坐标 + .attr("y", barY) // 使用与图像相同的y坐标 + .attr("width", imageWidth) + .attr("height", barHeight); + + // 使用裁剪路径显示部分图标 + d3.select(this) + .append("image") + .attr("x", barX) + .attr("y", barY) + .attr("width", barWidth) // 使用完整宽度 + .attr("height", barHeight) + .attr("clip-path", `url(#${clipPathId})`) + .attr("xlink:href", jsonData.images.field[group]); + } + + // 计算最后一个图标的位置，用于放置数值标签 + const lastGroupIndex = Math.floor(barCount / groupSize); + const lastInGroupIndex = barCount % groupSize; + let lastBarX = (lastGroupIndex * (groupSize * (barWidth + barSpacing) + largerGroupSpacing)) + + (lastInGroupIndex * (barWidth + barSpacing)); + + // 如果有小数部分，调整标签位置 + if (partialBar > 0) { + lastBarX += barWidth * partialBar; + } else if (barCount > 0) { + lastBarX += barWidth; + } + + // 添加数值标签 + d3.select(this) + .append("text") + .attr("x", lastBarX + 5) + .attr("y", barY + barHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colors.text_color) + .text(`${formatValue(value)}${yUnit ? ` ${yUnit}` : ''}`); + }); + }); + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..80198122c29bb68f8678042cbc565905a067f970 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_01.js.bug @@ -0,0 +1,483 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Pictorial Bar Chart", + "chart_name": "horizontal_group_pictorial_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 8], [0, "inf"], [2, 6]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + let dimensionField = '', valueField = '', groupField = ''; + + try { + dimensionField = dataColumns.find(col => col.role === "x").name; + valueField = dataColumns.find(col => col.role === "y").name; + groupField = dataColumns.find(col => col.role === "group").name; + } catch (error) { + console.error("数据列定义有误", error); + // 使用默认值防止出错 + dimensionField = dimensionField || "country"; + valueField = valueField || "value"; + groupField = groupField || "group"; + } + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + try { + if (dataColumns.find(col => col.role === "x") && + dataColumns.find(col => col.role === "x").unit !== "none") { + dimensionUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y") && + dataColumns.find(col => col.role === "y").unit !== "none") { + valueUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group") && + dataColumns.find(col => col.role === "group").unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + } catch (error) { + console.error("获取单位时出错", error); + } + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 创建临时SVG用于测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const tempText = tempSvg.append("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .text(dimension); + + const textWidth = tempText.node().getBBox().width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + + tempText.remove(); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const tempText = tempSvg.append("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", "bold") + .text(group); + + const textWidth = tempText.node().getBBox().width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + + tempText.remove(); + }); + + // 删除临时SVG + tempSvg.remove(); + + // === 修改点：结合维度标签和组标签最大宽度，重新计算margin.left === + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算每组需要的垂直空间 + const groupHeight = innerHeight / groups.length; + const groupPadding = innerHeight * (variables.has_spacing ? 0.08 : 0.06); // 组间距 + + // 每个维度的条形高度 + const barHeight = (groupHeight - groupPadding) / dimensions.length; + const actualBarHeight = variables.has_spacing ? barHeight * 0.65 : barHeight * 0.75; // 实际条形高度 + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", d3.rgb(baseColor).brighter(1.2)); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(baseColor).darker(0.7)); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colors.field && colors.field[group]) { + return colors.field[group]; + } + + // 如果有可用颜色数组，按索引使用 + if (colors.available_colors && colors.available_colors.length > 0) { + const groupIndex = groups.indexOf(group); + return colors.available_colors[groupIndex % colors.available_colors.length]; + } + + // 默认颜色方案 + // const defaultColors = { + // "$50 or more": "#ff725c", // 红色 + // "$1-49": "#4269d0", // 蓝色 + // "Nothing": "#3ca951" // 绿色 + // }; + // 默认颜色方案（修改部分） + const defaultColors = d3.schemeTableau10; // 使用D3内置的10色方案 + const groupIndex = groups.indexOf(group); + return defaultColors[groupIndex % defaultColors.length] || colors.other.primary || "#999"; + + // return defaultColors[group] || colors.other.primary || "#999"; + } + + // 获取描边颜色 + const getStrokeColor = () => { + if (colors.stroke_color) return colors.stroke_color; + if (colors.available_colors && colors.available_colors.length > 0) return colors.available_colors[0]; + return "#333333"; // 默认颜色 + }; + + + + // ---------- 10. 绘制图表 ---------- + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 计算该组的垂直位置 + const groupStartY = groupIndex * (groupHeight); + + // Create a group element for the label and its background + const groupLabelGroup = g.append("g") + .attr("transform", `translate(0, ${groupStartY - 10})`); + + // Create a temporary hidden text to measure dimensions + const tempText = groupLabelGroup.append("text") + .style("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .text(group); + + // Get the text dimensions + const textWidth = tempText.node().getBBox().width; + const textHeight = tempText.node().getBBox().height; + tempText.remove(); // Remove the temporary text + + // Add padding for the rectangle + const rectPadding = { x: 4, y: 2 }; + const shadowOffset = { x: 3, y: 3 }; // Shadow offset + + // Create rectangle dimensions + const rectX = -margin.left; + const rectY = -textHeight/2 - rectPadding.y; + const rectWidth = textWidth + rectPadding.x * 2 ; + const rectHeight = textHeight + rectPadding.y * 2; + const cornerRadius = rectPadding.y*2; + + // Create a path for a rectangle with rounded right corners + const createRoundedRectPath = (x, y, width, height, radius) => { + return [ + `M ${x} ${y}`, // Start at top-left + `H ${x + width - radius}`, // Line to top-right minus corner radius + `Q ${x + width} ${y} ${x + width} ${y + radius}`, // Top-right corner + `V ${y + height - radius}`, // Line to bottom-right minus corner radius + `Q ${x + width} ${y + height} ${x + width - radius} ${y + height}`, // Bottom-right corner + `H ${x}`, // Line to bottom-left + `V ${y}`, // Line to top-left + 'Z' // Close path + ].join(' '); + }; + + // Create the shadow rectangle + const shadowPath = createRoundedRectPath( + rectX + shadowOffset.x, + rectY + shadowOffset.y, + rectWidth, + rectHeight, + cornerRadius + ); + + groupLabelGroup.append("path") + .attr("d", shadowPath) + .attr("fill", "#cccccc"); // Gray shadow color + + // Create the main white rectangle + const mainPath = createRoundedRectPath(rectX, rectY, rectWidth, rectHeight, cornerRadius); + + groupLabelGroup.append("path") + .attr("d", mainPath) + .attr("fill", "#ffffff"); // White background color + + // Add the label text LAST so it's on top + groupLabelGroup.append("text") + .attr("x", -margin.left + 10) // Position text 10px from left margin + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // Left-align text + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", "#000000") // Black text color + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + // 为每个维度绘制条形 + dimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置 + const barY = groupStartY + dimIndex * barHeight; + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + barHeight/2})`); + + + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", - 5) // 左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colors.text_color || "#333") + .text(dimension); + + // 绘制条形 + g.append("image") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", actualBarHeight) // 略小于计算高度，留出间距 + .attr("xlink:href", jsonData.images.field[dataPoint[groupField]]) + .attr("preserveAspectRatio", "none"); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = `${formatValue(+dataPoint[valueField])}${valueUnit ? ` ${valueUnit}` : ''}`; + + // 创建临时文本元素来计算数值文本的宽度 + const tempText = g.append("text") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("visibility", "hidden") + .text(formattedValue); + + // 获取文本宽度 + const textWidth = tempText.node().getBBox().width; + + // 删除临时文本 + tempText.remove(); + + // 检查文本是否适合条形的宽度（考虑内边距） + const padding = 3; // 每侧5px内边距 + + // 如果条形太窄，无法容纳文本，则放在条形外部 + if (barWidth < textWidth + padding) { + g.append("text") + .attr("x", barWidth + 5) // 条形右侧5像素处 + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colors.text_color || "#333") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } else { + // 文本适合放在条形内部 + g.append("text") + .attr("x", barWidth + 5) + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", "#000000") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } + } + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_02.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_02.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..69427ddd01140f890bd6df6d99ee62cdf2a4dfd6 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_group_pictorial_bar_chart_02.js.bug @@ -0,0 +1,483 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Group Pictorial Bar Chart", + "chart_name": "horizontal_group_pictorial_bar_chart_02", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 8], [0, "inf"], [2, 6]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平分组条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 为标题和副标题预留空间，即使不显示它们 + const titleHeight = 70; // 为标题预留至少70的高度 + + // 分析图表区域底部边距 + const bottomMargin = 50; + + // 初始设置边距 + const margin = { + top: titleHeight, // 顶部留出标题空间 + right: 80, // 右侧足够显示数值 + bottom: bottomMargin, // 底部边距 + left: 150 // 左侧暂时设为最小值，稍后会根据标签长度调整 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列顺序提取字段名 + let dimensionField = '', valueField = '', groupField = ''; + + try { + dimensionField = dataColumns.find(col => col.role === "x").name; + valueField = dataColumns.find(col => col.role === "y").name; + groupField = dataColumns.find(col => col.role === "group").name; + } catch (error) { + console.error("数据列定义有误", error); + // 使用默认值防止出错 + dimensionField = dimensionField || "country"; + valueField = valueField || "value"; + groupField = groupField || "group"; + } + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + try { + if (dataColumns.find(col => col.role === "x") && + dataColumns.find(col => col.role === "x").unit !== "none") { + dimensionUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y") && + dataColumns.find(col => col.role === "y").unit !== "none") { + valueUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group") && + dataColumns.find(col => col.role === "group").unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + } catch (error) { + console.error("获取单位时出错", error); + } + + // ---------- 4. 数据处理 ---------- + + // 获取维度（如Gen Z, Millennials等）和分组（如$50 or more, $1-49, Nothing） + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // ---------- 5. 计算标签和图标空间 ---------- + + // 创建临时SVG用于测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算维度标签最大宽度 + let maxDimensionWidth = 0; + dimensions.forEach(dimension => { + const tempText = tempSvg.append("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .text(dimension); + + const textWidth = tempText.node().getBBox().width; + maxDimensionWidth = Math.max(maxDimensionWidth, textWidth); + + tempText.remove(); + }); + + // 计算分组标签最大宽度 + let maxGroupWidth = 0; + groups.forEach(group => { + const tempText = tempSvg.append("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", "bold") + .text(group); + + const textWidth = tempText.node().getBBox().width; + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + + tempText.remove(); + }); + + // 删除临时SVG + tempSvg.remove(); + + // === 修改点：结合维度标签和组标签最大宽度，重新计算margin.left === + const maxLabelWidth = Math.max(maxDimensionWidth, maxGroupWidth); + const dimensionLabelWidth = maxLabelWidth + 20; // 预留额外空间 + margin.left = Math.max(margin.left, dimensionLabelWidth + 20); + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // 计算每组需要的垂直空间 + const groupHeight = innerHeight / groups.length; + const groupPadding = innerHeight * (variables.has_spacing ? 0.08 : 0.06); // 组间距 + + // 每个维度的条形高度 + const barHeight = (groupHeight - groupPadding) / dimensions.length; + const actualBarHeight = variables.has_spacing ? barHeight * 0.65 : barHeight * 0.75; // 实际条形高度 + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建defs用于滤镜和渐变 + const defs = svg.append("defs"); + + // ---------- 6.1 创建视觉效果 ---------- + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + // 添加阴影效果组件 + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 4); + + filter.append("feOffset") + .attr("dx", 4) + .attr("dy", 4) + .attr("result", "offsetblur"); + + // 创建合并效果 + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getGroupColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", d3.rgb(baseColor).brighter(1.2)); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(baseColor).darker(0.7)); + }); + } + + // ---------- 7. 创建比例尺 ---------- + + // 计算最大值用于X轴比例尺 + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 值的X比例尺 + const xScale = d3.scaleLinear() + .domain([0, maxValue * 1.1]) // 添加10%边距 + .range([0, innerWidth]); + + // ---------- 8. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 辅助函数 ---------- + + // 获取组颜色 + function getGroupColor(group) { + // 优先使用指定颜色 + if (colors.field && colors.field[group]) { + return colors.field[group]; + } + + // 如果有可用颜色数组，按索引使用 + if (colors.available_colors && colors.available_colors.length > 0) { + const groupIndex = groups.indexOf(group); + return colors.available_colors[groupIndex % colors.available_colors.length]; + } + + // 默认颜色方案 + // const defaultColors = { + // "$50 or more": "#ff725c", // 红色 + // "$1-49": "#4269d0", // 蓝色 + // "Nothing": "#3ca951" // 绿色 + // }; + // 默认颜色方案（修改部分） + const defaultColors = d3.schemeTableau10; // 使用D3内置的10色方案 + const groupIndex = groups.indexOf(group); + return defaultColors[groupIndex % defaultColors.length] || colors.other.primary || "#999"; + + // return defaultColors[group] || colors.other.primary || "#999"; + } + + // 获取描边颜色 + const getStrokeColor = () => { + if (colors.stroke_color) return colors.stroke_color; + if (colors.available_colors && colors.available_colors.length > 0) return colors.available_colors[0]; + return "#333333"; // 默认颜色 + }; + + + + // ---------- 10. 绘制图表 ---------- + // 为每个组创建一个分组 + groups.forEach((group, groupIndex) => { + // 计算该组的垂直位置 + const groupStartY = groupIndex * (groupHeight); + + // Create a group element for the label and its background + const groupLabelGroup = g.append("g") + .attr("transform", `translate(0, ${groupStartY - 10})`); + + // Create a temporary hidden text to measure dimensions + const tempText = groupLabelGroup.append("text") + .style("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .text(group); + + // Get the text dimensions + const textWidth = tempText.node().getBBox().width; + const textHeight = tempText.node().getBBox().height; + tempText.remove(); // Remove the temporary text + + // Add padding for the rectangle + const rectPadding = { x: 4, y: 2 }; + const shadowOffset = { x: 3, y: 3 }; // Shadow offset + + // Create rectangle dimensions + const rectX = -margin.left; + const rectY = -textHeight/2 - rectPadding.y; + const rectWidth = textWidth + rectPadding.x * 2 ; + const rectHeight = textHeight + rectPadding.y * 2; + const cornerRadius = rectPadding.y*2; + + // Create a path for a rectangle with rounded right corners + const createRoundedRectPath = (x, y, width, height, radius) => { + return [ + `M ${x} ${y}`, // Start at top-left + `H ${x + width - radius}`, // Line to top-right minus corner radius + `Q ${x + width} ${y} ${x + width} ${y + radius}`, // Top-right corner + `V ${y + height - radius}`, // Line to bottom-right minus corner radius + `Q ${x + width} ${y + height} ${x + width - radius} ${y + height}`, // Bottom-right corner + `H ${x}`, // Line to bottom-left + `V ${y}`, // Line to top-left + 'Z' // Close path + ].join(' '); + }; + + // Create the shadow rectangle + const shadowPath = createRoundedRectPath( + rectX + shadowOffset.x, + rectY + shadowOffset.y, + rectWidth, + rectHeight, + cornerRadius + ); + + groupLabelGroup.append("path") + .attr("d", shadowPath) + .attr("fill", "#cccccc"); // Gray shadow color + + // Create the main white rectangle + const mainPath = createRoundedRectPath(rectX, rectY, rectWidth, rectHeight, cornerRadius); + + groupLabelGroup.append("path") + .attr("d", mainPath) + .attr("fill", "#ffffff"); // White background color + + // Add the label text LAST so it's on top + groupLabelGroup.append("text") + .attr("x", -margin.left + 10) // Position text 10px from left margin + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // Left-align text + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", "#000000") // Black text color + .text(group); + + // 筛选该组的数据 + const groupData = chartData.filter(d => d[groupField] === group); + // 为每个维度绘制条形 + dimensions.forEach((dimension, dimIndex) => { + // 查找数据点 + const dataPoint = groupData.find(d => d[dimensionField] === dimension); + + if (dataPoint) { + // 条形的垂直位置 + const barY = groupStartY + dimIndex * barHeight; + + // 条形宽度 + const barWidth = xScale(+dataPoint[valueField]); + + // 创建标签和图标组 + const labelGroup = g.append("g") + .attr("transform", `translate(0, ${barY + barHeight/2})`); + + + + // 绘制维度标签（右对齐，与图标的左边缘对齐） + labelGroup.append("text") + .attr("x", - 5) // 左侧5像素 + .attr("y", 0) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colors.text_color || "#333") + .text(dimension); + + // 绘制条形 + g.append("image") + .attr("x", 0) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", actualBarHeight) // 略小于计算高度，留出间距 + .attr("xlink:href", jsonData.images.field[dataPoint[groupField]]) + .attr("preserveAspectRatio", "none"); + + // 绘制数值标签（附加单位，如果有） + const formattedValue = `${formatValue(+dataPoint[valueField])}${valueUnit ? ` ${valueUnit}` : ''}`; + + // 创建临时文本元素来计算数值文本的宽度 + const tempText = g.append("text") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("visibility", "hidden") + .text(formattedValue); + + // 获取文本宽度 + const textWidth = tempText.node().getBBox().width; + + // 删除临时文本 + tempText.remove(); + + // 检查文本是否适合条形的宽度（考虑内边距） + const padding = 3; // 每侧5px内边距 + + // 如果条形太窄，无法容纳文本，则放在条形外部 + if (barWidth < textWidth + padding) { + g.append("text") + .attr("x", barWidth + 5) // 条形右侧5像素处 + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("fill", colors.text_color || "#333") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } else { + // 文本适合放在条形内部 + g.append("text") + .attr("x", barWidth - 5) + .attr("y", barY + actualBarHeight / 2) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(18,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("pointer-events", "none") + .text(formattedValue); + } + } + }); + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..0c39412ef4532a734da0442bf5be5c7b0c934034 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_01.js @@ -0,0 +1,478 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Lollipop Chart", + "chart_name": "horizontal_lollipop_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 30], [100000000, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "overlay", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + + +// 带图标的水平条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "bold" }, + description: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "16px", font_weight: "bold" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + variables.has_gradient = variables.has_gradient || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + let height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 40, // 右侧留出垂直标题块空间 + bottom: 60, // 底部边距 + left: 60 // 左侧留出描述文本空间 + }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 按数值降序排序数据 + const sortedData = [...chartData].sort((a, b) => +b[valueField] - +a[valueField]); + const sortedDimensions = sortedData.map(d => d[dimensionField]); + + // 动态调整高度：如果x维度数量超过15，每增加一个维度，高度增加3% + if (sortedDimensions.length > 15) { + const extraDimensions = sortedDimensions.length - 15; + const heightAdjustmentFactor = 1 + (extraDimensions * 0.03); // 增加比例因子 + height = Math.round(height * heightAdjustmentFactor); // 应用高度调整 + } + + // ---------- 5. 计算布局参数 ---------- + + // 创建临时SVG元素用于文本测量 + const tempSvgForWidth = d3.select(containerSelector) + .append("svg") + .attr("width", 1) // Minimal size + .attr("height", 1) + .style("position", "absolute") // Avoid affecting layout + .style("visibility", "hidden"); // Keep it hidden + + // 辅助函数：估算文本宽度 + const estimateTextWidth = (text, fontConfig) => { + return chartUtils.text.measure(tempSvgForWidth, text, { + fontFamily: fontConfig.font_family, + fontSize: fontConfig.font_size, + fontWeight: fontConfig.font_weight + }).width; + }; + + // 预计算所有维度标签的宽度 + const dimLabelWidths = {}; + sortedData.forEach(d => { + const dimensionText = d[dimensionField]; + dimLabelWidths[dimensionText] = estimateTextWidth(dimensionText, typography.label); + }); + + // 计算最大数值标签宽度 + let maxValueWidth = 0; + sortedData.forEach(d => { + const formattedValue = `${chartUtils.format.autoText(+d[valueField])}${valueUnit ? ` ${valueUnit}` : ''}`; + + const textWidth = chartUtils.text.measure(tempSvgForWidth, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + + // 删除临时SVG + tempSvgForWidth.remove(); + + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + + const gradient = defs.append("linearGradient") + .attr("id", "barGradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(primaryColor, { mode: "brighter", amount: 0.2 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", primaryColor); + } + + + + // ---------- 8. 创建比例尺 ---------- + + // 使用变量中定义的固定SVG尺寸 + // 不会调整SVG尺寸，而是让比例尺适应给定的空间 + + // 创建Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) // 使用固定的innerHeight + .padding(0.2); // 增加padding以确保有足够空间 + + // 根据比例尺的bandwidth计算行高和间距 + const rowHeight = yScale.bandwidth(); // 行高直接由比例尺决定 + const barHeight = Math.max(rowHeight * 0.6, 15); // 条形高度为行高的60%，但至少15px + + // 圆形图标的半径 - 与行高成比例 + const iconRadius = barHeight / 2; + const iconPadding = iconRadius / 4; + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, d3.max(sortedData, d => +d[valueField]) * 1.1]) // 添加10%边距 + .range([0, innerWidth - (iconRadius * 2 + iconPadding * 4)]); // 减去图标和边距空间 + + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建网格线组 - 将其放在数据条前面这样它们会显示在后面 + const gridGroup = g.append("g") + .attr("class", "grid-lines"); + + // 添加垂直网格线 + const gridValues = xScale.ticks(5); // 约 5 条竖直网格线 + + gridValues.forEach(value => { + gridGroup.append("line") + .attr("x1", xScale(value)) + .attr("y1", 0) + .attr("x2", xScale(value)) + .attr("y2", innerHeight) + .attr("stroke", "#e0e0e0") + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3,3"); // 虚线样式 + }); + + // 创建并添加底部值轴 + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickSize(0) // 不显示刻度线 + .tickPadding(8) + .tickFormat(d => chartUtils.format.autoText(d)); // 使用格式化函数 + + const xAxisGroup = g.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(xAxis); + + // 隐藏轴线 + xAxisGroup.select(".domain").attr("stroke", "none"); + + xAxisGroup.selectAll(".tick text") + .style("font-family", typography.annotation.font_family) + .style("font-size", "12px") // 初始字体大小 + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 动态调整X轴标签字体大小防止重叠 + const ticks = xAxisGroup.selectAll(".tick").nodes(); + const tickTexts = xAxisGroup.selectAll(".tick text").nodes(); + + if (ticks.length > 1 && tickTexts.length > 0) { + let maxWidth = 0; + tickTexts.forEach(text => { + maxWidth = Math.max(maxWidth, chartUtils.text.measure(xAxisGroup, text.textContent || "", { + fontFamily: typography.annotation.font_family, + fontSize: 12, + fontWeight: text.style.fontWeight || "normal" + }).width); + }); + + // 计算相邻刻度之间的最小距离 + let minDistance = Infinity; + for (let i = 1; i < ticks.length; i++) { + const tick1Transform = ticks[i-1].getAttribute('transform'); + const tick2Transform = ticks[i].getAttribute('transform'); + // 提取 translate(x, y) 中的 x 值 + const x1Match = tick1Transform.match(/translate\(([^,]+),/); + const x2Match = tick2Transform.match(/translate\(([^,]+),/); + if (x1Match && x2Match) { + const x1 = parseFloat(x1Match[1]); + const x2 = parseFloat(x2Match[1]); + minDistance = Math.min(minDistance, Math.abs(x2 - x1)); + } + + } + + const originalFontSize = 12; // 初始字体大小 + const minAllowedFontSize = 6; // 最小允许字体大小 + const paddingFactor = 0.95; // 刻度间距的填充因子 + + if (maxWidth > minDistance * paddingFactor) { + const scaleFactor = (minDistance * paddingFactor) / maxWidth; + let newFontSize = Math.max(minAllowedFontSize, originalFontSize * scaleFactor); + + xAxisGroup.selectAll(".tick text") + .style("font-size", `${newFontSize}px`); + } + } + + // ---------- 11. 为每个维度绘制条形和标签 ---------- + + // 获取主题色 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + + // 获取描边颜色的辅助函数 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + + sortedData.forEach((d, i) => { + const dimension = d[dimensionField]; + + const value = +d[valueField]; + + const y = yScale(dimension); + const barWidth = xScale(value); + + // 1. 绘制粗横线（替代原来的条形） + g.append("line") + .attr("x1", 0) + .attr("y1", y + barHeight / 2) + .attr("x2", barWidth) + .attr("y2", y + barHeight / 2) + .attr("stroke", primaryColor) + .attr("stroke-width", barHeight / 4) // 使用一半的条形高度作为线宽 + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // Define circle position early for label calculation + const circleX = barWidth; + const circleY = y + barHeight / 2; + + // 3. 添加类别标题（在条形左侧上方 或 图标右侧） + const dimLabelWidth = dimLabelWidths[dimension]; + const circleLeftEdge = circleX - iconRadius; + const labelPadding = 5; // Define padding + + let labelX = 0; // Default position: left + let labelAnchor = "start"; + let labelY = y; // 维持标准高度位置 + + // 默认使用标准字体大小 + let labelFontSize = typography.label.font_size; + + // Check if label overlaps with the icon circle area + if (dimLabelWidth > circleLeftEdge - labelPadding) { + // 如果标签与圆圈区域重叠，将标签移到圆圈右侧 + labelX = circleX + iconRadius + labelPadding; + // labelAnchor remains "start" + + // 重要修改：当标签在右侧时，缩小字体大小而不是移动位置 + // 计算可用垂直空间 - 约为条形高度的60%，确保在垂直方向上不会与数值标签重叠 + const availableHeight = barHeight * 0.6; + + // 获取原始字体大小（移除单位） + const originalSize = parseFloat(labelFontSize); + + // 根据可用高度计算新字体大小，但不小于8px + const reducedSize = Math.max(8, Math.min(originalSize, availableHeight)); + + // 更新字体大小 + labelFontSize = `${reducedSize}px`; + } + + g.append("text") + .attr("x", labelX) // Use calculated X position + .attr("y", labelY) // 保持原始Y位置 + .attr("text-anchor", labelAnchor) // Use calculated anchor + .style("font-family", typography.label.font_family) + .style("font-size", labelFontSize) // 使用计算后的字体大小 + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 4. 添加图标圆圈（在线的右端） + // Use the already defined circleX, circleY + + // 绘制主色调圆圈 + g.append("circle") + .attr("cx", circleX) + .attr("cy", circleY) + .attr("r", iconRadius) + .attr("fill", primaryColor) // 使用主题色填充圆圈 + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + // 图标尺寸稍小于圆圈 + const iconSize = iconRadius * 1.5; + + g.append("image") + .attr("x", circleX - iconSize / 2) + .attr("y", circleY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 5. 添加数值标签（在圆圈右侧） + const formattedValue = `${chartUtils.format.autoText(value)}${valueUnit ? ` ${valueUnit}` : ''}`; + + g.append("text") + .attr("x", circleX + iconRadius + iconPadding * 2) // Use circleX here + .attr("y", circleY) // Use circleY here + .attr("dy", "0.35em") + .attr("text-anchor", "start") + .style("font-family", typography.annotation.font_family) + .style("font-size",`${Math.min(20,Math.max(barHeight * 0.5, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedValue); + }); + + // ---------- 12. 辅助函数 ---------- + + // 文本换行函数 + function wrapText(text, width, lineHeight) { + text.each(function() { + const text = d3.select(this); + const words = text.text().split(/\s+/).reverse(); + let word; + let line = []; + let lineNumber = 0; + const y = text.attr("y"); + const dy = parseFloat(text.attr("dy") || 0); + const textMeasureOptions = { + fontFamily: text.style("font-family") || typography.annotation.font_family, + fontSize: parseFloat(text.style("font-size")) || parseFloat(typography.annotation.font_size), + fontWeight: text.style("font-weight") || typography.annotation.font_weight + }; + const measureTextWidth = value => chartUtils.text.measure(null, value, textMeasureOptions).width; + let tspan = text.text(null).append("tspan") + .attr("x", 0) + .attr("y", y) + .attr("dy", dy + "em"); + + while (word = words.pop()) { + line.push(word); + tspan.text(line.join(" ")); + if (measureTextWidth(line.join(" ")) > width) { + line.pop(); + tspan.text(line.join(" ")); + line = [word]; + tspan = text.append("tspan") + .attr("x", 0) + .attr("y", y) + .attr("dy", ++lineNumber * lineHeight + dy + "em") + .text(word); + } + } + }); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..0bed0fee1afef3f0b4d8812f59db8f0dff9b519f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_lollipop_chart_02.js @@ -0,0 +1,612 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Lollipop Chart", + "chart_name": "horizontal_lollipop_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical", "temporal"], ["numerical"]], + "required_fields_range": [[2, 16], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const jsonData = data || {}; + const sourceData = (jsonData.data && jsonData.data.data) || []; + const dataColumns = chartUtils.schema.columns(jsonData); + const colorResolver = chartUtils.color.resolver(jsonData); + const chartUtilsFormatSample = chartUtils.format.autoText; + const chartUtilsTextSample = chartUtils.text.estimate; + const chartUtilsStandard = { + schema: chartUtils.schema, + format: chartUtils.format, + text: chartUtils.text, + color: chartUtils.color, + legendLayout: chartUtils.legend.layout, + legendDraw: chartUtils.legend.draw, + random: chartUtils.random.generator(jsonData, "dev-wz-style") + }; + const standardChannels = chartUtils.schema.channels(jsonData, { + x: { fallbackIndex: 0 }, + y: { fallbackIndex: 1 }, + y2: { fallbackIndex: 2 }, + y3: { fallbackIndex: 3 }, + size: { fallbackIndex: 2 }, + group: { fallbackIndex: 2 }, + group2: { fallbackIndex: 3 }, + group3: { fallbackIndex: 4 } + }); + const variables = jsonData.variables || {}; + const typography = jsonData.typography || {}; + const sourceColors = jsonData.colors || {}; + const colorOther = sourceColors.other || {}; + + d3.select(containerSelector).html(""); + + const xColumn = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }).raw || {}; + const yColumn = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }).raw || {}; + const xField = xColumn.name; + const yField = yColumn.name; + const xType = xColumn.data_type || "categorical"; + const xUnit = (xColumn.unit || "").trim(); + const yUnit = (yColumn.unit || "").trim(); + + const width = Number(variables.width) || 600; + const height = Number(variables.height) || 600; + const textColor = sourceColors.text_color || "#243042"; + const mutedText = "#64748b"; + const gridColor = "#d7e1ea"; + const primaryColor = colorOther.primary || "#2563eb"; + const fontFamily = (typography.label && typography.label.font_family) || + (typography.title && typography.title.font_family) || + "Arial, sans-serif"; + const annotationFamily = (typography.annotation && typography.annotation.font_family) || fontFamily; + const labelWeight = (typography.label && typography.label.font_weight) || "700"; + const valueWeight = (typography.annotation && typography.annotation.font_weight) || "700"; + const baseLabelSize = parseFloat(typography.label && typography.label.font_size) || 12; + const baseValueSize = parseFloat(typography.annotation && typography.annotation.font_size) || 11; + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("class", "horizontal-lollipop-root"); + + function showMessage(message) { + svg.append("text") + .attr("x", width / 2) + .attr("y", height / 2) + .attr("text-anchor", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", "16px") + .text(message); + return svg.node(); + } + + if (!xField || !yField) { + return showMessage("Missing lollipop fields"); + } + + function cleanLabel(value) { + return String(value ?? "") + .replace(/_/g, " ") + .replace(/([a-z])([A-Z])/g, "$1 $2") + .replace(/\s+/g, " ") + .trim(); + } + + function readableName(value) { + return cleanLabel(value).replace(/\b\w/g, letter => letter.toUpperCase()); + } + + function rgba(color, opacity) { + const c = d3.rgb(color); + return `rgba(${c.r}, ${c.g}, ${c.b}, ${opacity})`; + } + + function compactNumber(value) { + const numeric = Number(value); + if (!Number.isFinite(numeric)) return String(value ?? ""); + const abs = Math.abs(numeric); + if (abs >= 1000000000) return `${d3.format(".3~g")(numeric / 1000000000)}B`; + if (abs >= 1000000) return `${d3.format(".3~g")(numeric / 1000000)}M`; + if (abs >= 1000) return `${d3.format(".3~g")(numeric / 1000)}K`; + return d3.format(",.4~g")(numeric); + } + + function formatLocalValue(value, includeUnit = true) { + const formatted = compactNumber(value); + if (!includeUnit || !yUnit || yUnit === "none") return formatted; + const currencyWithSuffix = yUnit.match(/^([£$€¥])\s*([A-Za-z]+)$/); + if (yUnit === "%") return `${formatted}%`; + if (currencyWithSuffix) return `${currencyWithSuffix[1]}${formatted}${currencyWithSuffix[2]}`; + if (/^[£$€¥]$/.test(yUnit)) return `${yUnit}${formatted}`; + return `${formatted} ${yUnit}`; + } + + function parseTemporalRank(value) { + const text = String(value ?? "").trim(); + let match = text.match(/^(-?\d{4})$/); + if (match) return Number(match[1]) * 10000; + match = text.match(/^(-?\d{4})[-/.](\d{1,2})(?:[-/.](\d{1,2}))?$/); + if (match) return Number(match[1]) * 10000 + Number(match[2]) * 100 + Number(match[3] || 1); + match = text.match(/^q([1-4])\s*(-?\d{4})$/i) || text.match(/^(-?\d{4})\s*q([1-4])$/i); + if (match && match[1].length === 1) return Number(match[2]) * 10 + Number(match[1]); + if (match) return Number(match[1]) * 10 + Number(match[2]); + return NaN; + } + + function parseOrdinalRank(value) { + const text = String(value ?? "").trim().toLowerCase(); + let match = text.match(/^(\d+(?:\.\d+)?)\s*(?:-|to)\s*\d+(?:\.\d+)?/); + if (match) return Number(match[1]); + match = text.match(/^(\d+(?:\.\d+)?)\s*\+$/); + if (match) return Number(match[1]); + match = text.match(/^less\s+than\s+[$€£¥]?(\d[\d,]*)/); + if (match) return Number(match[1].replace(/,/g, "")) - 1; + match = text.match(/^more\s+than\s+[$€£¥]?(\d[\d,]*)/); + if (match) return Number(match[1].replace(/,/g, "")) + 1; + match = text.match(/^[$€£¥]?(\d[\d,]*)\s*-\s*[$€£¥]?(\d[\d,]*)/); + if (match) return Number(match[1].replace(/,/g, "")); + match = text.match(/^(-?\d+(?:\.\d+)?)(?:st|nd|rd|th)?\b/); + if (match) return Number(match[1]); + const rankedPatterns = [ + [/teen|13-17|under\s*18/, 13], + [/young|18-24/, 18], + [/25-34/, 25], + [/35-44/, 35], + [/45-54/, 45], + [/55-64/, 55], + [/65\+|senior/, 65], + [/very\s+low|lowest/, 100], + [/\blow\b|entry|basic/, 200], + [/medium|moderate|middle|standard/, 300], + [/\bhigh\b|advanced/, 400], + [/very\s+high|highest|premium/, 500] + ]; + for (const [pattern, rank] of rankedPatterns) { + if (pattern.test(text)) return rank; + } + return NaN; + } + + const grouped = new Map(); + sourceData.forEach((row, index) => { + const label = cleanLabel(row[xField]); + const value = Number(row[yField]); + if (!label || !Number.isFinite(value) || value < 0) return; + if (!grouped.has(label)) { + grouped.set(label, { + label, + rawLabel: row[xField], + values: [], + sourceIndexes: [], + firstIndex: index, + temporalRank: parseTemporalRank(row[xField]), + ordinalRank: parseOrdinalRank(row[xField]) + }); + } + grouped.get(label).values.push(value); + grouped.get(label).sourceIndexes.push(index); + }); + + const rows = Array.from(grouped.values()).map(d => ({ + ...d, + value: d3.mean(d.values) + })); + if (rows.length < 2) { + return showMessage("Not enough data for horizontal lollipop chart"); + } + + const allTemporal = xType === "temporal" || rows.every(d => Number.isFinite(d.temporalRank)); + const allOrdinal = !allTemporal && rows.every(d => Number.isFinite(d.ordinalRank)); + const sortMode = allTemporal ? "chronological" : (allOrdinal ? "ordered category" : "ranked by value"); + const sortedData = rows.slice().sort((a, b) => { + if (allTemporal) return d3.ascending(a.temporalRank, b.temporalRank) || d3.ascending(a.firstIndex, b.firstIndex); + if (allOrdinal) return d3.ascending(a.ordinalRank, b.ordinalRank) || d3.ascending(a.firstIndex, b.firstIndex); + return d3.descending(a.value, b.value) || d3.ascending(a.label, b.label); + }).map((d, index) => ({ ...d, rank: index + 1 })); + + const measure = svg.append("g").attr("visibility", "hidden"); + function measureLabelText(text, fontSize, family = fontFamily, weight = labelWeight) { + const node = measure.append("text") + .style("font-family", family) + .style("font-size", `${fontSize}px`) + .style("font-weight", weight) + .text(String(text ?? "")) + .node(); + const measured = node ? node.textContent.length * 7 : 0; + measure.selectAll("text").remove(); + return Math.max(measured || 0, String(text ?? "").length * fontSize * 0.52); + } + + function compactText(text, maxWidth, fontSize, family = fontFamily, weight = labelWeight) { + const full = String(text ?? ""); + if (measureLabelText(full, fontSize, family, weight) <= maxWidth) return full; + const words = full.split(/\s+/).filter(Boolean); + if (words.length > 1) { + const firstLast = `${words[0]} ${words[words.length - 1]}`; + if (measureLabelText(firstLast, fontSize, family, weight) <= maxWidth) return firstLast; + const initialLast = `${words[0][0]}. ${words[words.length - 1]}`; + if (measureLabelText(initialLast, fontSize, family, weight) <= maxWidth) return initialLast; + } + const slashWidth = measureLabelText("/", fontSize, family, weight); + let head = Math.max(2, Math.ceil(full.length * 0.48)); + let tail = Math.max(2, full.length - head); + while (head > 1 && tail > 1) { + const candidate = `${full.slice(0, head).trim()}/${full.slice(full.length - tail).trim()}`; + if (measureLabelText(candidate, fontSize, family, weight) + slashWidth <= maxWidth) return candidate; + if (head >= tail) head -= 1; + else tail -= 1; + } + return full.slice(0, Math.max(3, Math.floor(maxWidth / (fontSize * 0.62)))); + } + + function withOpacity(color, opacity) { + const parsed = d3.color(color) || d3.color(primaryColor) || d3.color("#14b8a6"); + parsed.opacity = opacity; + return parsed.formatRgb(); + } + + function bindRow(selection) { + return selection + .attr("data-label", d => d.label) + .attr("data-category", d => d.label) + .attr("data-value", d => d.value) + .attr("data-source-index", d => d.firstIndex) + .attr("data-source-indexes", d => d.sourceIndexes.join(",")) + .attr("data-source-count", d => d.values.length) + .attr("data-rank", d => d.rank) + .attr("data-sort-mode", sortMode); + } + + const defs = svg.append("defs"); + const shadow = defs.append("filter") + .attr("id", "horizontal-lollipop-soft-shadow") + .attr("x", "-20%") + .attr("y", "-20%") + .attr("width", "140%") + .attr("height", "140%"); + shadow.append("feDropShadow") + .attr("dx", 0) + .attr("dy", 3) + .attr("stdDeviation", 4) + .attr("flood-color", "#0f2f43") + .attr("flood-opacity", 0.12); + + const gradient = defs.append("linearGradient") + .attr("id", "horizontal-lollipop-line-gradient") + .attr("x1", "0%") + .attr("x2", "100%") + .attr("y1", "0%") + .attr("y2", "0%"); + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", withOpacity(primaryColor, 0.76)); + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", primaryColor); + + svg.append("rect") + .attr("class", "chart-canvas") + .attr("width", width) + .attr("height", height) + .attr("fill", sourceColors.background_color || "#eefaf8") + .attr("opacity", 0.22); + + const outerPad = Math.max(12, width * 0.026); + const cardX = outerPad; + const cardY = Math.max(8, height * 0.018); + const cardW = width - outerPad * 2; + const cardH = height - cardY - outerPad; + const stripH = Math.max(40, Math.min(58, height * 0.12)); + const headerH = Math.max(30, Math.min(42, height * 0.085)); + const noteGap = Math.max(8, height * 0.016); + const plotTop = cardY + headerH + Math.max(6, height * 0.012); + const plotBottom = cardY + cardH - stripH - noteGap - Math.max(26, height * 0.06); + const innerHeight = Math.max(150, plotBottom - plotTop); + const rowCount = sortedData.length; + const yScale = d3.scaleBand() + .domain(sortedData.map(d => d.label)) + .range([0, innerHeight]) + .padding(rowCount > 10 ? 0.18 : 0.26); + const rowGap = Math.max(1, yScale.step()); + const badgeRadius = Math.max(9, Math.min(17, yScale.bandwidth() * 0.42)); + const iconColWidth = Math.max(34, badgeRadius * 2 + 16); + const labelColumnWidth = Math.max(72, Math.min(132, width * 0.22)); + const valueCircleRadius = rowCount > 10 + ? Math.max(8.5, Math.min(12, yScale.bandwidth() * 0.42)) + : Math.max(12, Math.min(18, yScale.bandwidth() * 0.46)); + const rightPad = valueCircleRadius * 2 + Math.max(28, width * 0.055); + const plotX = cardX + iconColWidth + labelColumnWidth + 14; + const plotW = Math.max(110, cardX + cardW - plotX - rightPad); + const labelFontSize = Math.max(7.8, Math.min(baseLabelSize, rowGap * 0.31)); + const valueFontSize = Math.max(6.4, Math.min(baseValueSize, valueCircleRadius * 0.52)); + const maxValue = Math.max(1, d3.max(sortedData, d => d.value) || 1); + const xScale = d3.scaleLinear() + .domain([0, maxValue]) + .nice(5) + .range([0, plotW]); + const domainMax = xScale.domain()[1]; + const ticks = xScale.ticks(5); + const lineWidth = Math.max(5, Math.min(10, yScale.bandwidth() * 0.26)); + + svg.append("rect") + .attr("class", "chart-card") + .attr("x", cardX) + .attr("y", cardY) + .attr("width", cardW) + .attr("height", cardH) + .attr("rx", 12) + .attr("fill", "#ffffff") + .attr("stroke", "#dcebe8") + .attr("filter", "url(#horizontal-lollipop-soft-shadow)") + .attr("opacity", 0.96); + + const chart = svg.append("g") + .attr("class", "lollipop-chart") + .attr("data-tag", "chart") + .attr("transform", `translate(${plotX}, ${plotTop})`); + + svg.append("text") + .attr("class", "table-header-label category-header") + .attr("x", cardX + iconColWidth) + .attr("y", cardY + headerH * 0.62) + .attr("fill", textColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.5, baseValueSize * 0.82)}px`) + .style("font-weight", 800) + .style("letter-spacing", "0") + .text(readableName(xColumn.label || xColumn.name || xField)); + + svg.append("text") + .attr("class", "table-header-label value-header") + .attr("x", plotX + plotW + valueCircleRadius) + .attr("y", cardY + headerH * 0.62) + .attr("text-anchor", "middle") + .attr("fill", primaryColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.5, baseValueSize * 0.82)}px`) + .style("font-weight", 900) + .text(yUnit && yUnit !== "none" ? `% / ${yUnit}`.replace("% / %", "%") : readableName(yColumn.label || yColumn.name || yField)); + + ticks.forEach(tick => { + const x = xScale(tick); + chart.append("line") + .attr("class", "gridline") + .attr("x1", x) + .attr("x2", x) + .attr("y1", 0) + .attr("y2", innerHeight) + .attr("stroke", gridColor) + .attr("stroke-width", 1) + .attr("stroke-dasharray", "3 4") + .attr("opacity", 0.72); + chart.append("text") + .attr("class", "axis-tick") + .attr("x", x) + .attr("y", innerHeight + 18) + .attr("text-anchor", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.5, valueFontSize * 0.9)}px`) + .style("font-weight", valueWeight) + .text(formatLocalValue(tick, false)); + }); + + chart.append("line") + .attr("class", "axis-baseline") + .attr("x1", 0) + .attr("x2", plotW) + .attr("y1", innerHeight) + .attr("y2", innerHeight) + .attr("stroke", rgba(textColor, 0.36)) + .attr("stroke-width", 1); + + const rowsG = chart.selectAll(".lollipop-row") + .data(sortedData) + .enter() + .append("g") + .attr("class", "lollipop-row") + .attr("data-label", d => d.label) + .attr("data-category", d => d.label) + .attr("data-value", d => d.value) + .attr("data-source-index", d => d.firstIndex) + .attr("data-source-indexes", d => d.sourceIndexes.join(",")) + .attr("data-source-count", d => d.values.length) + .attr("data-rank", d => d.rank) + .attr("data-sort-mode", sortMode) + .attr("transform", d => `translate(0, ${yScale(d.label) + yScale.bandwidth() / 2})`); + + rowsG.append("line") + .attr("class", "row-divider") + .attr("x1", -iconColWidth - labelColumnWidth) + .attr("x2", plotW + rightPad * 0.72) + .attr("y1", yScale.bandwidth() / 2 + yScale.paddingInner() * rowGap * 0.5) + .attr("y2", yScale.bandwidth() / 2 + yScale.paddingInner() * rowGap * 0.5) + .attr("stroke", "#dce6e6") + .attr("stroke-dasharray", "3 4") + .attr("opacity", 0.6); + + bindRow(rowsG.append("circle") + .attr("class", "category-icon-badge") + .attr("cx", -labelColumnWidth - iconColWidth * 0.5) + .attr("cy", 0)) + .attr("r", badgeRadius) + .attr("fill", withOpacity(primaryColor, 0.12)) + .attr("stroke", withOpacity(primaryColor, 0.18)) + .attr("stroke-width", 1); + + bindRow(rowsG.append("text") + .attr("class", "category-icon-glyph") + .attr("x", -labelColumnWidth - iconColWidth * 0.5) + .attr("y", 0)) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "central") + .attr("fill", primaryColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(6.8, badgeRadius * 0.7)}px`) + .style("font-weight", 900) + .text(d => d.rank); + + rowsG.append("text") + .attr("class", "category-label") + .attr("x", -16) + .attr("y", 0) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .attr("fill", textColor) + .style("font-family", fontFamily) + .style("font-size", `${labelFontSize}px`) + .style("font-weight", labelWeight) + .text(d => compactText(xUnit && xUnit !== "none" ? `${d.label} ${xUnit}` : d.label, labelColumnWidth, labelFontSize)); + + bindRow(rowsG.append("line") + .attr("class", "lollipop-track") + .attr("x1", 0) + .attr("x2", plotW) + .attr("y1", 0) + .attr("y2", 0)) + .attr("stroke", "#ecf4f1") + .attr("stroke-width", lineWidth) + .attr("stroke-linecap", "round"); + + bindRow(rowsG.append("line") + .attr("class", "lollipop-line bar") + .attr("data-tag", "mark") + .attr("x1", 0) + .attr("x2", d => xScale(d.value)) + .attr("y1", 0) + .attr("y2", 0)) + .attr("stroke", primaryColor) + .attr("stroke-width", lineWidth) + .attr("stroke-linecap", "round") + .attr("opacity", 0.92); + + bindRow(rowsG.append("circle") + .attr("class", "lollipop-dot data-point mark") + .attr("data-tag", "mark") + .attr("cx", d => xScale(d.value)) + .attr("cy", 0)) + .attr("r", valueCircleRadius) + .attr("fill", primaryColor) + .attr("stroke", "#ffffff") + .attr("stroke-width", 2); + + bindRow(rowsG.append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.value)) + .attr("y", 0)) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .attr("fill", "#ffffff") + .attr("paint-order", "stroke") + .attr("stroke", withOpacity(primaryColor, 0.14)) + .attr("stroke-width", 1) + .style("font-family", annotationFamily) + .style("font-size", `${valueFontSize}px`) + .style("font-weight", 900) + .text(d => formatLocalValue(d.value, true)); + + chart.append("text") + .attr("class", "axis-title") + .attr("x", plotW / 2) + .attr("y", innerHeight + 44) + .attr("text-anchor", "middle") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8.4, baseValueSize * 0.86)}px`) + .style("font-weight", valueWeight) + .text(yUnit && yUnit !== "none" + ? `${readableName(yColumn.label || yColumn.name || yField)} (${yUnit})` + : readableName(yColumn.label || yColumn.name || yField)); + + const stripY = cardY + cardH - stripH - Math.max(9, height * 0.014); + const strip = svg.append("g") + .attr("class", "source-strip") + .attr("transform", `translate(${cardX + 12},${stripY})`); + strip.append("rect") + .attr("width", cardW - 24) + .attr("height", stripH) + .attr("rx", 10) + .attr("fill", withOpacity(primaryColor, 0.10)) + .attr("stroke", withOpacity(primaryColor, 0.12)); + + const topRow = sortedData.slice().sort((a, b) => d3.descending(a.value, b.value))[0]; + const lowRow = sortedData.slice().sort((a, b) => d3.ascending(a.value, b.value))[0]; + const insight = strip.append("g") + .attr("class", "insight-card") + .attr("data-top-label", topRow ? topRow.label : "") + .attr("data-top-value", topRow ? topRow.value : "") + .attr("data-low-label", lowRow ? lowRow.label : "") + .attr("data-low-value", lowRow ? lowRow.value : "") + .attr("transform", `translate(${Math.max(12, cardW * 0.03)},${stripH / 2})`); + insight.append("circle") + .attr("class", "insight-icon") + .attr("cx", 0) + .attr("cy", 0) + .attr("r", Math.max(8, Math.min(12, stripH * 0.24))) + .attr("fill", primaryColor); + insight.append("text") + .attr("x", 0) + .attr("y", 1) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .attr("fill", "#ffffff") + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(8, stripH * 0.23)}px`) + .style("font-weight", 900) + .text("i"); + insight.append("text") + .attr("class", "summary-value") + .attr("x", Math.max(18, stripH * 0.42)) + .attr("y", -2) + .attr("dominant-baseline", "middle") + .attr("fill", textColor) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.8, Math.min(9.4, baseValueSize * 0.78))}px`) + .style("font-weight", 800) + .text(topRow ? `${compactText(topRow.label, Math.max(60, cardW * 0.24), 9, annotationFamily, valueWeight)} leads at ${formatLocalValue(topRow.value, true)}` : ""); + + const sortLabel = sortMode === "chronological" + ? "chronological order" + : (sortMode === "ordered category" ? "ordered category scale" : "ranked by value"); + svg.append("text") + .attr("class", "category-note") + .attr("x", cardX + 18) + .attr("y", stripY - 9) + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.8, baseValueSize * 0.76)}px`) + .text(`${readableName(xColumn.label || xColumn.name || xField)}: ${sortLabel}`); + + svg.append("text") + .attr("class", "scale-note") + .attr("x", cardX + cardW - 18) + .attr("y", stripY - 9) + .attr("text-anchor", "end") + .attr("fill", mutedText) + .style("font-family", annotationFamily) + .style("font-size", `${Math.max(7.8, baseValueSize * 0.76)}px`) + .text(`Scale 0-${formatLocalValue(domainMax, true)}`); + + measure.remove(); + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..047dd7e573ab3f97f09245abdc5c5448333d05d9 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_bar_chart_01.js.bug @@ -0,0 +1,213 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Pictorial Bar Chart", + "chart_name": "horizontal_pictorial_bar_chart_01", + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[3, 20], [0, 100000]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": ["gradient", "opacity"], + "min_height": 300, + "min_width": 300, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + } + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 300; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + + // ---------- 4. 数据处理 ---------- + + // 处理数据，确保数据格式正确 + const processedData = chartData.map(d => ({ + category: d[xField], + value: +d[yField], // 确保转换为数字 + icon: jsonData.images.field[d[xField]] + })).sort((a, b) => b.value - a.value); // 按值降序排序 + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用分类数据 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartHeight]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.value)]) + .range([0, chartWidth]) + .nice(); + + // 颜色比例尺 + const colorScale = d3.scaleOrdinal() + .domain(processedData.map(d => d.category)) + .range([colors.other.primary, colors.other.primary]); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴（隐藏） + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickFormat(d => d + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color) + .style("opacity", 0); // 隐藏X轴文本 + + // 添加Y轴（不显示刻度线） + const yAxis = d3.axisLeft(yScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .call(g => g.select(".domain").remove()) // 移除轴线 + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + + // 添加条形 + const bars = chartGroup.selectAll(".bar") + .data(processedData) + .enter() + .append("image") + .attr("class", "bar") + .attr("y", d => yScale(d.category)) + .attr("x", 0) + .attr("height", yScale.bandwidth()) + .attr("width", d => xScale(d.value)) // 直接设置最终宽度 + .attr("preserveAspectRatio", "none") + .attr("xlink:href", d => d.icon); + + // 绘制数值标签 + chartGroup.selectAll(".label") + .data(processedData) + .enter() + .append("text") + .attr("class", "label") + .attr("y", d => yScale(d.category) + yScale.bandwidth() / 2) + .attr("x", d => xScale(d.value) + 5) + .attr("dy", ".35em") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color) + .text(d => `${formatValue(d.value)}${yUnit ? ` ${yUnit}` : ''}`) + .style("opacity", 1); // 直接设置为可见 + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..9a6e267a2eee3aac7554e4a83fca4b4cca9b920b --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_01.js.bug @@ -0,0 +1,327 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Pictorial Percentage Bar Chart", + "chart_name": "horizontal_pictorial_percentage_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 10], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": [], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 实现花瓶形状的柱状图 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + other: { primary: "#4682B4", secondary: "#FF7F50" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = jsonData.data.columns || []; // 使用data_columns + + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名称 ---------- + let xField, yField; + + // 安全地提取字段名称 + const xColumn = dataColumns.find(col => col.role === "x"); + const yColumn = dataColumns.find(col => col.role === "y"); + + if (xColumn) xField = xColumn.name; + if (yColumn) yField = yColumn.name; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; // 默认为百分比 + + if (dataColumns.find(col => col.role === "x").unit !== "none") { + dimensionUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y").unit !== "none") { + valueUnit = dataColumns.find(col => col.role === "y").unit; + } + + // ---------- 3. 数据处理 ---------- + // 按照y值降序排序数据 + const sortedData = [...chartData].sort((a, b) => b[yField] - a[yField]); + + // ---------- 4. 尺寸和布局设置 ---------- + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 120, // 减少顶部空间 + right: 30, + bottom: 80, // 国旗和标签的空间 + left: 30 + }; + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + // 创建主图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 6. 创建比例尺 ---------- + // X轴比例尺（瓶子之间的间隔） + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d[xField])) + .range([0, innerWidth]) + .padding(0.2); + + // Y轴比例尺（瓶子的高度） + const yMax = d3.max(sortedData, d => d[yField]); + const yScale = d3.scaleLinear() + .domain([0, yMax * 1.1]) // 添加10%的空间 + .range([innerHeight, 0]); + + // ---------- 7. 创建瓶子和蒙版 ---------- + // 定义瓶子的宽度和高度 (不修改这部分) + const bottleWidth = xScale.bandwidth(); + const bottleHeight = Math.max(bottleWidth * 3, innerHeight * 0.5); + + // 获取瓶子的主要颜色 + const bottleColor = colors.other.primary || "#4CAF50"; + + // 定义国旗和文本的空间 + const flagTextHeight = 50; + + // 计算瓶子底部应在的位置 - 让瓶子底部接近国旗 + const bottleBottomY = innerHeight - 10; // 瓶子底部位置，紧贴国旗上方 + const bottleTopY = bottleBottomY - bottleHeight; // 瓶子顶部位置 + + // 创建一个数组来存储所有的值标签元素引用 + const valueLabels = []; + + // 添加瓶子图像和蒙版 + chart.selectAll(".bottle-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "bottle-group") + .attr("transform", d => `translate(${xScale(d[xField])}, ${bottleTopY})`) + .each(function(d, i) { + const group = d3.select(this); + const bottlePercentage = d[yField] / yMax; + + // 为第一个（最高值）瓶子使用不同的图像 + const imagebase64_2 = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="547" height="1410" viewBox="0 0 547 1410">
  <image id="瓶1" y="17" width="547" height="1381" xlink:href="data:img/png;base64,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"/>
</svg>
" + const imagebase64 = "data:image/svg+xml;base64,<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
<svg version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="547px" height="1410px" viewBox="0 0 547 1410" enable-background="new 0 0 547 1410" xml:space="preserve">  <image id="image0" width="547" height="1410" x="0" y="0"
    xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAiMAAAWCCAYAAADGzed0AAAAIGNIUk0AAHomAACAhAAA+gAAAIDo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=" />
</svg>
"; // 这里是最高值瓶子的图像 + + // 根据索引选择不同的图像 + const bottleImage = (i === 0) ? imagebase64_2 : imagebase64; + + group.append("image") + .attr("xlink:href", bottleImage) + .attr("width", bottleWidth) + .attr("height", bottleHeight) + .attr("preserveAspectRatio","xMidYMid meet"); + + // 添加瓶子蒙版（白色部分） + group.append("rect") + .attr("class", "bottle-mask") + .attr("width", bottleWidth) + .attr("height", bottleHeight * (1 - bottlePercentage)) + .attr("fill", "white") + .attr("opacity", 0.6); + + // 计算标签方块的大小和位置 + const squareSize = bottleWidth * 0.6; // 正方形边长为瓶子宽度的60% + const squareX = (bottleWidth - squareSize) / 2; // 水平居中 + const squareY = bottleHeight * (2/3) - (squareSize / 2); // 从底部往上1/3的位置 + + // 添加正方形背景 + group.append("rect") + .attr("class", "value-bg") + .attr("x", squareX) + .attr("y", squareY) + .attr("width", squareSize) + .attr("height", squareSize) + .attr("fill", "#f5f5f5") + .attr("rx", 5) + .attr("ry", 5); + + // 格式化值 + const formattedValue = valueUnit ? + `${d[yField]}${valueUnit}` : + `${d[yField]}`; + + // 我们将在下面计算实际字体大小，先使用基础大小创建文本元素 + const baseValueFontSize = 16; + + // 添加数值文本但先不设置字体大小 + const valueText = group.append("text") + .attr("class", "value-label") + .attr("x", bottleWidth / 2) + .attr("y", squareY + (squareSize * 0.6)) // 先设置一个位置，稍后会调整 + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold") + .style("fill", "#333") + .style("font-size", `${baseValueFontSize}px`) // 先设置基础字体大小 + .text(formattedValue); + + // 将值标签添加到数组中，以便后续统一调整 + valueLabels.push({ + element: valueText, + value: formattedValue, + squareSize: squareSize + }); + }); + + // ---------- 8. 添加国旗和国家名称 ---------- + const baseLabelFontSize = 14; // 基础字体大小 + const countryLabels = []; // 存储所有国家标签文本元素的引用 + + // 创建临时文本元素来测量文本宽度 + const tempText = svg.append("text") + .attr("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-size", `${baseLabelFontSize}px`); + + // 计算所有维度标签的最大宽度 + const dimensionWidths = sortedData.map(d => { + tempText.text(d[xField]); + return tempText.node().getComputedTextLength(); + }); + + // 最大可用宽度为bandWidth的90% + const maxAvailableWidth = xScale.bandwidth() * 1.2; + + // 计算需要的缩放比例 (如果有标签超出可用宽度) + const labelScaleFactor = Math.min(1, maxAvailableWidth / Math.max(...dimensionWidths)); + + // 确定最终的统一字体大小 + const finalLabelFontSize = baseLabelFontSize * labelScaleFactor; + + // 移除临时元素 + tempText.remove(); + + chart.selectAll(".flag-label-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "flag-label-group") + .attr("transform", d => `translate(${xScale(d[xField]) + xScale.bandwidth() / 2}, ${innerHeight + 10})`) + .each(function(d, i) { + const group = d3.select(this); + + // 添加国旗（如果有） + if (images.field && images.field[d[xField]]) { + group.append("image") + .attr("xlink:href", images.field[d[xField]]) + .attr("x", -12) + .attr("y", 0) + .attr("width", xScale.bandwidth()*0.3) + .attr("height", xScale.bandwidth()*0.25) + .attr("preserveAspectRatio","xMidYMid meet"); + + // 添加国家名称 - 使用统一的字体大小 + const label = group.append("text") + .attr("class", "country-label") + .attr("x", 0) + .attr("y", xScale.bandwidth()*0.45) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalLabelFontSize}px`) + .style("fill", colors.text_color) + .text(d[xField]); + + countryLabels.push(label); + } else { + // 如果没有国旗，添加没有国旗版本的标签 - 使用相同的字体大小 + const label = group.append("text") + .attr("class", "country-label") + .attr("x", 0) + .attr("y", 15) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", `${finalLabelFontSize}px`) + .style("fill", colors.text_color) + .text(d[xField]); + + countryLabels.push(label); + } + }); + + // ---------- 9. 统一调整所有值标签的字体大小 ---------- + // 创建临时文本元素来测量值标签文本宽度 + const tempValueText = svg.append("text") + .attr("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold") + .style("font-size", `${baseValueFontSize}px`); + + // 计算所有值标签在基础字体大小下的实际宽度 + const valueTextWidths = valueLabels.map(item => { + tempValueText.text(item.value); + return tempValueText.node().getComputedTextLength(); + }); + + // 计算每个标签所需的缩放比例（方形宽度 / 文本宽度） + const valueScaleFactors = valueLabels.map((item, i) => { + // 使用60%的方形宽度作为最大可用宽度 + const maxWidth = item.squareSize * 1; // 留一些边距 + return maxWidth / valueTextWidths[i]; + }); + + // 取最小的缩放比例，确保所有值标签使用相同的字体大小 + const minValueScaleFactor = Math.min(...valueScaleFactors, 1); // 不要放大，只缩小 + + // 计算最终的统一字体大小 + const finalValueFontSize = Math.min(baseValueFontSize * minValueScaleFactor, baseValueFontSize); + + // 移除临时元素 + tempValueText.remove(); + + // 应用统一的字体大小到所有值标签 + valueLabels.forEach(item => { + item.element + .style("font-size", `${finalValueFontSize}px`); + }); + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_02.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_02.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..888e9212d9278b196fb78715c0b85d0ae3128faf --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_pictorial_percentage_bar_chart_02.js.bug @@ -0,0 +1,318 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Pictorial Percentage Bar Chart", + "chart_name": "horizontal_pictorial_percentage_bar_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 7], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": [], + "supported_effects": [], + "min_height": 400, + "min_width": 500, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 实现水平花瓶形状的柱状图 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "28px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + other: { primary: "#4682B4", secondary: "#FF7F50" } + }; + const images = jsonData.images || { field: {}, other: {} }; + const dataColumns = jsonData.data.columns || []; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 提取字段名称 ---------- + let xField, yField; + const xColumn = dataColumns.find(col => col.role === "x"); + const yColumn = dataColumns.find(col => col.role === "y"); + if (xColumn) xField = xColumn.name; + if (yColumn) yField = yColumn.name; + + let dimensionUnit = ""; + let valueUnit = ""; + if (xColumn && xColumn.unit !== "none") dimensionUnit = xColumn.unit; + if (yColumn && yColumn.unit !== "none") valueUnit = yColumn.unit; + + // ---------- 3. 数据处理 ---------- + // 按y值降序排序数据 (optional, depends on desired vertical order) + const sortedData = [...chartData].sort((a, b) => b[yField] - a[yField]); + + // ---------- 4. 尺寸和布局设置 ---------- + const initialWidth = variables.width || 800; + const initialHeight = variables.height || 600; + const iconWidth = 24; // Width reserved for icons + const iconPadding = 20; // Padding between icon and text + const labelPadding = 20; // Padding between text and chart area start + + // --- Pre-calculate Label Width --- + const tempSvg = d3.select(containerSelector).append("svg").attr("width", 0).attr("height", 0); + const tempText = tempSvg.append("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size || "16px") + .style("font-weight", typography.label.font_weight || 500); + + let maxLabelWidth = 0; + sortedData.forEach(d => { + tempText.text(d[xField]); + const textWidth = tempText.node().getComputedTextLength(); + let totalWidth = textWidth + labelPadding; + if (images.field && images.field[d[xField]]) { + totalWidth += iconWidth + iconPadding; + } + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + tempSvg.remove(); // Clean up temporary SVG + + // --- Final Dimensions and Margins --- + const margin = { + top: 60, // Adjusted for potential title space + right: 30, + bottom: 40, + left: Math.max(50, maxLabelWidth + 30) // Ensure minimum margin, accommodate labels/icons + }; + + const width = initialWidth; + const height = initialHeight; + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 5. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") // Use 100% width for responsiveness + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 创建背景路径： + svg.append("path") + .attr("d", `M ${margin.left} ${margin.top} + h ${innerWidth} + v ${innerHeight} + h ${-innerWidth} + Z`) + .attr("fill", "#ffffff") + + // 创建主图表组 (shifted right by margin.left) + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建标签组 (positioned absolutely to the left) + const labelGroup = svg.append("g") + .attr("transform", `translate(0, ${margin.top})`); // Align top with chart group + + // ---------- 6. 创建比例尺 ---------- + // Y轴比例尺 (Categorical - vertical distribution) + const yScale = d3.scaleBand() + .domain(sortedData.map(d => d[xField])) + .range([0, innerHeight]) + .padding(0.1); // Adjust padding as needed + + // X轴比例尺 (Numerical - horizontal length) + const yMax = d3.max(sortedData, d => d[yField]) || 1; // Handle empty data + const maxlen = Math.min(innerWidth,yScale.bandwidth()*3.2) + const xScale = d3.scaleLinear() + .domain([0, yMax * 1.05]) // Add 5% headroom + .range([0, maxlen]); // Represents the length + + // ---------- 7. 创建瓶子、蒙版、标签和图标 ---------- + const barHeight = yScale.bandwidth(); + + // --- Draw Dimension Labels and Icons (Left Side) --- + labelGroup.selectAll(".dimension-label-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "dimension-label-group") + .attr("transform", d => `translate(0, ${yScale(d[xField]) + barHeight / 2})`) // Center vertically + .each(function(d) { + const group = d3.select(this); + const iconUrl = images.field ? images.field[d[xField]] : null; + let textX = margin.left - labelPadding; // Start position for text (right aligned) + + // Add Icon if available + if (iconUrl) { + group.append("image") + .attr("xlink:href", iconUrl) + .attr("x", textX - iconWidth) // Position icon to the left of text start + .attr("y", -iconWidth / 2) // Center icon vertically + .attr("width", iconWidth) + .attr("height", iconWidth) + .attr("preserveAspectRatio", "xMidYMid meet"); + textX -= (iconWidth + iconPadding); // Adjust text start position further left + } + + // Add Text Label + group.append("text") + .attr("x", textX) + .attr("y", 0) // Already centered by group transform + .attr("text-anchor", "end") // Align text to the right + .attr("dominant-baseline", "central") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size || "16px") + .style("font-weight", typography.label.font_weight || 500) + .style("fill", colors.text_color) + .text(d[xField]); + }); + + // --- Draw Bottles and Masks (Right Side) --- + const valueLabelsData = []; // To store info for adjusting value font size later + + chart.selectAll(".bottle-bar-group") + .data(sortedData) + .enter() + .append("g") + .attr("class", "bottle-bar-group") + .attr("transform", d => `translate(0, ${yScale(d[xField])})`) // Position vertically + .each(function(d, i) { + const group = d3.select(this); + const filledWidth = xScale(d[yField]); + const barHeight = yScale.bandwidth(); // Height of the horizontal bar + + // 为第一个（最高值）瓶子使用不同的图像 + const imagebase64_2 = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="978.35" height="387.43" viewBox="0 0 5755 2279">
  <image id="图层_1" data-name="图层 1" x="-24" width="5755" height="2279" xlink:href="data:img/png;base64,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"/>
</svg>
" + const imagebase64 = "data:image/svg+xml;base64,<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="976.32" height="379.84" viewBox="0 0 24408 9496">
  <image id="图层_1" data-name="图层 1" width="24408" height="9496" xlink:href="data:img/png;base64,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"/>
</svg>
" + const bottleImage = (i === 0 && imagebase64_2) ? imagebase64_2 : imagebase64; // Choose image + + // Add bottle image - horizontal and scaled to filledWidth + if (bottleImage) { + group.append("image") + .attr("xlink:href", bottleImage) + .attr("x", 0) // 修改：图像从条形区域左侧开始 + .attr("y", 0) // 修改：图像从条形区域顶部开始 + .attr("width",maxlen) // 修改：图像宽度为填充宽度 + .attr("height", barHeight) // 修改：图像高度为条形高度 + // 控制图像内容如何适应这个定义的框 + // 'none' - 拉伸图像填满框 + // 'xMinYMid meet' - 保持宽高比，完整显示，可能留白 + // 'xMinYMid slice' - 保持宽高比，填满框，可能裁剪 + .attr("preserveAspectRatio", "xMinYMid meet"); // 修改：改为 'xMinYMid meet' 或 'none' 尝试，移除旋转 + + } else { + // Fallback rectangle if no image + group.append("rect") + .attr("x", 0) + .attr("y", 0) + .attr("width", filledWidth) + .attr("height", barHeight) + .attr("fill", colors.other.primary || "#4CAF50"); + } + + + // Add bottle mask (covers the unfilled portion on the right) + group.append("rect") + .attr("class", "bottle-mask") + .attr("x", filledWidth+20) // Start mask where fill ends + .attr("y", 0) + .attr("width", Math.max(0, maxlen - filledWidth)) // Width of the unfilled part + .attr("height", barHeight) + .attr("fill", "white") // Or background color + .attr("opacity", 0.5); // Adjust opacity + + // Value Label Background (optional, centered in filled part) + const valueSquareSize = barHeight * 0.6 + const valueSquareX = barHeight*0.6; // Center in filled part, ensure min X + const valueSquareY = (barHeight - valueSquareSize) / 2; // Center vertically + + if (valueSquareSize > 10) { // Only show if reasonably sized + group.append("rect") + .attr("class", "value-bg") + .attr("x", valueSquareX) + .attr("y", valueSquareY) + .attr("width", valueSquareSize) + .attr("height", valueSquareSize) + .attr("fill", "#f5f5f5") + .attr("rx", 3) + .attr("ry", 3) + .attr("opacity", 0.8); + } + + // Value Label Text (Prepare for font sizing) + const formattedValue = valueUnit ? `${d[yField]}${valueUnit}` : `${d[yField]}`; + const valueText = group.append("text") + .attr("class", "value-label") + .attr("x", valueSquareX+valueSquareSize/2) // Center in filled portion + .attr("y", barHeight / 2) // Center vertically + .attr("text-anchor", "middle") + .attr("dominant-baseline", "central") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold") + .style("fill", "#333") + .text(formattedValue); // Text content + + valueLabelsData.push({ + element: valueText, + value: formattedValue, + maxWidth: Math.max(10, valueSquareSize * 0.9), // Available width inside square (with padding) + maxHeight: Math.max(10, valueSquareSize * 0.9) // Available height inside square + }); + }); + + // ---------- 8. Adjust Value Label Font Size ---------- + const baseValueFontSize = 14; // Starting font size + let finalValueFontSize = baseValueFontSize; + + // Create temp text element for measurement + const tempValueText = svg.append("text") + .attr("visibility", "hidden") + .style("font-family", typography.label.font_family) + .style("font-weight", "bold"); + + // Find the minimum scale factor needed across all labels + let minScaleFactor = 1.0; + valueLabelsData.forEach(item => { + if (item.maxWidth < 5 || item.maxHeight < 5) { + item.element.text(""); // Hide text if space is too small + return; + } + tempValueText.style("font-size", `${baseValueFontSize}px`).text(item.value); + const textWidth = tempValueText.node().getComputedTextLength(); + // Rough height estimate (adjust multiplier if needed) + const textHeight = baseValueFontSize * 1.2; + + const widthScale = item.maxWidth / textWidth; + const heightScale = item.maxHeight / textHeight; + minScaleFactor = Math.min(minScaleFactor, widthScale, heightScale); + }); + + finalValueFontSize = baseValueFontSize * Math.max(0, minScaleFactor); // Ensure non-negative size + + // Apply the final uniform font size (or hide if too small) + valueLabelsData.forEach(item => { + if (finalValueFontSize < 6) { // Threshold for visibility + item.element.text(""); + } else { + item.element.style("font-size", `${finalValueFontSize}px`); + } + }); + tempValueText.remove(); // Clean up + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_range_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_range_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..1b0eb1b5654101a96ab1246d6dcb0c754aa99124 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_range_chart_01.js @@ -0,0 +1,428 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Range Chart", + "chart_name": "horizontal_range_bar_chart_01", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 20], [0, "inf"], [2, 2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "dark", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js实现水平分裂条形图 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如未提供则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部空间用于标题 + right: 20, // 右侧边距用于值标签 + bottom: 60, // 底部边距 + left: 100 // 左侧用于维度标签 + }; + + // ---------- 3. 提取字段名称和单位 ---------- + + // 根据数据列顺序提取字段名称 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key; + const valueField = chartUtils.schema.channel(jsonData, "y").key; + const groupField = chartUtils.schema.channel(jsonData, "group").key; + + // 获取字段单位（如果存在） + let dimensionUnit = ""; + let valueUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + dimensionUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + //if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + // valueUnit = chartUtils.schema.channel(jsonData, "y").unit; + //} + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // 数值格式化函数 + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的维度值和组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 如有需要可以对维度进行排序 - 当前使用原始顺序 + + // ---------- 5. 计算标签宽度 ---------- + + // 创建临时SVG以测量文本宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 初始填充值（将根据条形高度进行调整） + const flagPadding = 5; + + // 计算最大维度标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（如果存在单位则添加） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = textWidth; + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算值标签的最大宽度 + let maxValueWidth = 0; + chartData.forEach(d => { + const formattedValue = valueUnit ? + `${d[valueField]}${valueUnit}` : + `${chartUtils.format.autoText(+d[valueField])}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + + maxValueWidth = Math.max(maxValueWidth, textWidth); + }); + // 删除临时SVG + tempSvg.remove(); + + // 根据标签宽度调整左边距（添加一些边距） + margin.left = Math.max(margin.left, maxLabelWidth + 10); + margin.right = Math.max(margin.right, maxValueWidth + 10); + + // 计算内部绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 首先创建defs元素（必须在使用前创建） + const defs = svg.append("defs"); + + // 创建背景渐变 + const bgGradient = defs.append("linearGradient") + .attr("id", "background-gradient") + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "100%"); + + bgGradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", "#4a0032"); + + bgGradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", "#1c3b6e"); + + // 添加渐变背景（在所有其他元素之前） + svg.append("rect") + .attr("width", width) + .attr("height", height) + .attr("class", "background") + .attr("fill", "url(#background-gradient)") + .attr("opacity", 1.0); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 7. 创建坐标轴比例尺 ---------- + + // 计算额外的条形间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） - 使用原始顺序 + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于值） + // 找到最小和最大值来设置范围 + const minValue = d3.min(chartData, d => +d[valueField]); + const maxValue = d3.max(chartData, d => +d[valueField]); + + // 修改X轴范围确保最小值和最大值都在刻度范围内 + // 这里使用更大的倍数以确保有足够的空间 + const xScale = d3.scaleLinear() + .domain([Math.min(minValue, 0) * 1.15, maxValue + 5]) + .range([0, innerWidth]); + + + // 颜色比例尺（用于组） + const colorScale = colorResolver.scale(groups, { colors: ["#1d3c6f", "#6fa0d8"] }); + chartUtils.legend.centered(svg, groups, { + colorScale, + colorResolver, + colors, + }, width / 2, margin.top - 25, { + markerShape: "circle", + markerSize: 15.0, + labelGap: 5, + itemGap: 10, + maxWidth: width - 10, + fitToWidth: true, + minFontSize: 8, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: "#ffffff", + }); + // ---------- 9. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + + + // ---------- 10. 添加网格线（Y轴） ---------- + + // 添加垂直网格线（刻度标记） + const xTicks = xScale.ticks(10); + + // 添加网格线 + g.selectAll(".grid-line") + .data(xTicks) + .enter() + .append("line") + .attr("class", "grid-line") + .attr("x1", d => xScale(d)) + .attr("y1", 0) + .attr("x2", d => xScale(d)) + .attr("y2", innerHeight) + .attr("stroke", "rgba(255, 255, 255, 0.15)") + .attr("stroke-width", 1); + + // 在底部添加X轴值 + g.selectAll(".x-tick-label") + .data(xTicks) + .enter() + .append("text") + .attr("class", "x-tick-label") + .attr("x", d => xScale(d)) + .attr("y", innerHeight + 20) + .attr("text-anchor", "middle") + .style("font-family", "Arial") + .style("font-size", "12px") + .style("fill", "white") + .text(d => chartUtils.format.autoText(d)); + + // ---------- 11. 添加交替行背景 ---------- + + if (jsonData.variation && jsonData.variation.background === "styled") { + dimensions.forEach((dimension, i) => { + + g.append("rect") + .attr("x", -margin.left + 10) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left + margin.right - 20) + .attr("height", yScale.bandwidth()) + .attr("class", "background") + .attr("fill", "rgba(255, 255, 255, 0.05)") + .attr("rx", 4) + .attr("ry", 4); + + }); + } + + // ---------- 12. 绘制条形和标记 ---------- + const barHeight = yScale.bandwidth(); + // 找到最右侧的刻度位置，用于连接线终点 + const rightmostTickX = xScale(xTicks[xTicks.length - 1]); + + dimensions.forEach(dimension => { + // 获取此维度的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + if (dimensionData.length > 0) { + const barHeight = yScale.bandwidth(); + const labelY = yScale(dimension) + barHeight / 2; + + // 添加维度标签 + g.append("text") + .attr("x", -5) + .attr("y", labelY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", "#ffffff") + .text(dimension); + + // 两个组的数据 + const pointData = groups.map(group => { + const dataPoint = dimensionData.find(d => d[groupField] === group); + if (dataPoint) { + return { + group: group, + value: +dataPoint[valueField], + x: xScale(+dataPoint[valueField]), + y: yScale(dimension) + barHeight / 2 + }; + } + return null; + }).filter(d => d !== null); + + // 绘制连接线（从最低值数据点到右边缘） + if (pointData.length > 0) { + // 找到具有最低值的数据点 + const lowestValueData = pointData.reduce((lowest, current) => + current.value < lowest.value ? current : lowest, pointData[0]); + + if (lowestValueData) { + // 绘制连接线 - 更粗并精确到最右侧刻度线 + g.append("rect") + .attr("x", lowestValueData.x) + .attr("y", lowestValueData.y - 2) // 更粗的线 + .attr("width", rightmostTickX - lowestValueData.x) + .attr("height", 4) // 更粗的线 + .attr("fill", "#ffffff"); + } + } + + // 添加每个数据点的标记（圆圈） + pointData.forEach((point, i) => { + // 绘制标记圆圈 + g.append("circle") + .attr("cx", point.x) + .attr("cy", point.y) + .attr("r", 8) + .attr("fill", colorScale(point.group)) + .attr("stroke", "white") + .attr("stroke-width", 2); + + // 添加值标签 - 修改这里保留小数点和小数部分 + const formattedValue = valueUnit ? + `${chartUtils.format.autoText(point.value)}${valueUnit}` : + `${chartUtils.format.autoText(point.value)}`; + + const labelFontSize = Math.min(20, Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size))); + const textBBox = chartUtils.text.measure(svg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: labelFontSize, + fontWeight: "bold", + }); + const textPadding = 8; // 文本两侧的小填充 + const labelWidth = textBBox.width + textPadding * 2; + const labelHeight = textBBox.height + textPadding; + + // 创建样式化值标签 - 移到圆圈右侧 + g.append("rect") + .attr("x", point.x + 12) // 从圆圈右侧开始 + .attr("y", point.y - labelHeight/2) // 垂直居中 + .attr("width", labelWidth) + .attr("height", labelHeight) + .attr("rx", 6) + .attr("ry", 6) + .attr("fill", colorScale(point.group)) + .attr("stroke", "white") + .attr("stroke-width", 1); + + // 修改文本位置 + g.append("text") + .attr("x", point.x + 12 + labelWidth/2) // 文本在矩形中央 + .attr("y", point.y) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", "bold") + .style("fill", "white") + .text(formattedValue); + }); + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_0.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_0.js new file mode 100644 index 0000000000000000000000000000000000000000..c26ca3473c678ae1bf6c32ddb0cddda63bcfb1d5 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_0.js @@ -0,0 +1,314 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 200 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, chartWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const formattedText = `${chartUtils.format.autoText(value)}${yUnit}`; + const textwidth = measureTextWidth(formattedText, typography.annotation.font_size); + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formattedText : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()) + yAxis.selectAll("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + let bandWidth = yScale.bandwidth() + let iconSize = yScale.bandwidth()*0.7 + let iconPadding = 10; + // 添加文本和图标 + yAxis.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + if(jsonData.images && jsonData.images.field[d]) { + tick.append("image") + .attr("x", - iconSize - iconPadding) // 10是原有的padding + .attr("y", -iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[d]); + tick.select("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("x", -iconSize-2*iconPadding) + } + }); + + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(svg, text, { fontFamily, fontSize, fontWeight }).width; + } + + /* ============ 4. 添加动态图例 ============ */ + if (groups && groups.length > 0) { + const legendMarkerWidth = 12; // 图例标记宽度 + const legendMarkerHeight = 12; // 图例标记高度 + const legendMarkerRx = 3; // 图例标记圆角X + const legendPadding = 6; // 图例标记和文本之间的间距 + const legendInterItemSpacing = 12; // 图例项之间的水平间距 + + const legendFontFamily = typography.label.font_family || 'Arial'; // 图例字体 + const legendFontSize = parseFloat(typography.label.font_size || '11'); // 图例字号 + const legendFontWeight = typography.label.font_weight || 'normal'; // 图例字重 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + const availableWidthForLegendWrapping = chartWidth; + const itemMaxHeight = Math.max(legendMarkerHeight, legendFontSize); // 单行图例内容的最大高度 + const legendOptions = { + color: group => colorResolver.field(group, 0, { fallback: primaryColor }).value, + markerShape: "rect", + markerWidth: legendMarkerWidth, + markerHeight: legendMarkerHeight, + markerSize: legendMarkerWidth, + markerRadius: legendMarkerRx, + markerOpacity: 0.85, + labelGap: legendPadding, + itemGap: legendInterItemSpacing, + rowGap: 6, + itemHeight: itemMaxHeight, + itemPaddingEnd: 0, + maxWidth: availableWidthForLegendWrapping, + align: "center", + fontFamily: legendFontFamily, + fontSize: legendFontSize, + fontWeight: legendFontWeight, + textColor: "#333", + className: "custom-legend-container", + }; + const legendLayout = chartUtils.legend.layout(groups, { ...legendOptions, context: svg }); + + if (legendLayout.items.length > 0) { + const paddingBelowLegendToChart = 15; // 图例块底部与图表顶部的间距 + const minSvgGlobalTopPadding = 15; // SVG顶部到图例块的最小间距 + + let legendBlockStartY = margin.top - paddingBelowLegendToChart - legendLayout.height; + legendBlockStartY = Math.max(minSvgGlobalTopPadding, legendBlockStartY); // 确保不超出SVG顶部 + + chartUtils.legend.draw(svg, groups, { + ...legendOptions, + x: (width - availableWidthForLegendWrapping) / 2, + y: legendBlockStartY, + }); + + // 添加字段名称 - 居中于图例上方 + svg.append("text") + .attr("x", width / 2) + .attr("y", legendBlockStartY - 10) // 放在图例上方，保持间距 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "alphabetic") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + } + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_1.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_1.js new file mode 100644 index 0000000000000000000000000000000000000000..dbf044e93520e0ef3ec6476f355e2b1b2d460733 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_1.js @@ -0,0 +1,560 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 10000], [3, 20]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 200 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 布局计算和字体调整 ---------- + + const dimLabelMaxWidth = width * 0.25; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 14; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = chartWidth; + let innerHeight = chartHeight; + + // 计算行间距 + const rowPadding = 0.3; + + // Y轴比例尺（用于维度）- 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([innerHeight, 0]) + .padding(rowPadding); + + const rowHeight = yScale.bandwidth(); + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: processedData.map(d => d.period), + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: rowHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 根据标签宽度调整左边距 + margin.left = maxLabelWidth + 15; + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // 重新计算Y轴比例尺（使用新的innerHeight） + yScale.range([innerHeight, 0]); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, innerWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const formattedText = `${chartUtils.format.autoText(value)}${yUnit}`; + const textwidth = measureTextWidth(formattedText, typography.annotation.font_size); + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formattedText : ''; + }); + + // 添加总和值标注 + chartGroup.selectAll(".total-label") + .data(processedData) + .enter().append("text") + .attr("class", "total-label") + .attr("y", d => yScale(d.period) + yScale.bandwidth() / 2) + .attr("x", d => xScale(d.total) + 5) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => `${chartUtils.format.autoText(d.total)}${yUnit}`); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴（支持多行标签） + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => "")) + .call(g => g.select(".domain").remove()); + + // 手动添加Y轴标签（支持多行） + processedData.forEach(d => { + const period = d.period; + const labelConfig = dimLabelConfig[period]; + const centerY = yScale(period) + rowHeight / 2; + + const labelGroup = yAxis.append("text") + .attr("x", -10) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", -10) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + }); + + function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(svg, text, { fontFamily, fontSize, fontWeight }).width; + } + + /* ============ 4. 添加动态图例 ============ */ + if (groups && groups.length > 0) { + const legendMarkerWidth = 12; // 图例标记宽度 + const legendMarkerHeight = 12; // 图例标记高度 + const legendMarkerRx = 3; // 图例标记圆角X + const legendPadding = 6; // 图例标记和文本之间的间距 + const legendInterItemSpacing = 12; // 图例项之间的水平间距 + + const legendFontFamily = typography.label.font_family || 'Arial'; // 图例字体 + const legendFontSize = parseFloat(typography.label.font_size || '11'); // 图例字号 + const legendFontWeight = typography.label.font_weight || 'normal'; // 图例字重 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + const availableWidthForLegendWrapping = innerWidth; + const itemMaxHeight = Math.max(legendMarkerHeight, legendFontSize); // 单行图例内容的最大高度 + const legendOptions = { + color: group => colorResolver.field(group, 0, { fallback: primaryColor }).value, + markerShape: "rect", + markerWidth: legendMarkerWidth, + markerHeight: legendMarkerHeight, + markerSize: legendMarkerWidth, + markerRadius: legendMarkerRx, + markerOpacity: 0.85, + labelGap: legendPadding, + itemGap: legendInterItemSpacing, + rowGap: 6, + itemHeight: itemMaxHeight, + itemPaddingEnd: 0, + maxWidth: availableWidthForLegendWrapping, + align: "center", + fontFamily: legendFontFamily, + fontSize: legendFontSize, + fontWeight: legendFontWeight, + textColor: "#333", + className: "custom-legend-container", + }; + const legendLayout = chartUtils.legend.layout(groups, { ...legendOptions, context: svg }); + + if (legendLayout.items.length > 0) { + const paddingBelowLegendToChart = 15; // 图例块底部与图表顶部的间距 + const minSvgGlobalTopPadding = 15; // SVG顶部到图例块的最小间距 + + let legendBlockStartY = margin.top - paddingBelowLegendToChart - legendLayout.height; + legendBlockStartY = Math.max(minSvgGlobalTopPadding, legendBlockStartY); // 确保不超出SVG顶部 + + chartUtils.legend.draw(svg, groups, { + ...legendOptions, + x: (width - availableWidthForLegendWrapping) / 2, + y: legendBlockStartY, + }); + + // 添加字段名称 - 居中于图例上方 + svg.append("text") + .attr("x", width / 2) + .attr("y", legendBlockStartY - 10) // 放在图例上方，保持间距 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "alphabetic") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + } + } + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_10.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_10.js new file mode 100644 index 0000000000000000000000000000000000000000..4e1f3441b611a459f078b7d35036952fc5a29255 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_10.js @@ -0,0 +1,381 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_8_hand", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 8], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 100, // 增加右侧边距，为图标预留空间 + bottom: 80, + left: 50 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.4); // 增加内边距，增加条形图之间的间距 + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total) * 1.1]) // 增加10%空间 + .range([0, chartWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 用于测量文本宽度的辅助函数 + function measureTextWidth(text, fontSize) { + return chartUtils.text.measure(null, text, { fontSize: parseFloat(fontSize) || fontSize }).width; + } + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加组标签（在条形图上半部分） + layers.selectAll(".group-label-bg") + .data(d => d) + .enter().append("rect") + .attr("class", "group-label-bg") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.35 - 8) // 位置稍微调整以包围文本 + .attr("x", d => xScale(d[0]) + 5) // 与文本对齐 + .attr("height", 16) // 固定高度包围文本 + .attr("width", 0) // 宽度将在文本添加后调整 + .style("fill", "#ffffff") + .style("opacity", 0.5); + + layers.selectAll(".group-label") + .data(d => d) + .enter().append("text") + .attr("class", "group-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.35) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#000000") // 改为黑色 + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text((d, i, nodes) => { + // 获取当前rect所属的layer组，从而获取group名称 + const parentGroup = d3.select(nodes[i].parentNode); + const groupData = parentGroup.datum(); + + // 检查宽度，如果太小则不显示 + const width = xScale(d[1]) - xScale(d[0]); + if (width < 5) return ""; // 当宽度太小时不显示标签 + + return groupData.key; // 使用堆叠数据的key作为group label + }) + .each(function(d, i) { + // 为每个标签设置背景矩形的宽度 + const text = d3.select(this); + const textContent = text.text(); + if (textContent) { + const fontSize = text.style("font-size"); + const textWidth = measureTextWidth(textContent, fontSize); + // 获取对应的背景矩形并设置宽度 + const bgRect = d3.select(this.parentNode).selectAll(".group-label-bg").filter((_, j) => j === i); + bgRect.attr("width", textWidth + 10); // 加10px的内边距 + } + }); + + // 添加数值标注背景（在条形图下半部分） + layers.selectAll(".value-label-bg") + .data(d => d) + .enter().append("rect") + .attr("class", "value-label-bg") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.7 - 8) // 位置调整以包围文本 + .attr("x", d => xScale(d[0]) + 5) // 与文本对齐 + .attr("height", 16) // 固定高度包围文本 + .attr("width", 0) // 宽度将在文本添加后调整 + .style("fill", "#ffffff") + .style("opacity", 0.5); + + // 添加数值标注（在条形图下半部分） + layers.selectAll(".value-label") + .data(d => d) + .enter().append("text") + .attr("class", "value-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.7) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#000000") // 改为黑色 + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + const value = d[1] - d[0]; + // 只有在有值的情况下才显示 + if (value <= 0) return "0"; // 不显示 + + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + + // 检查宽度，如果太小或值为0则不显示 + if (width < 5 || value <= 0) return ""; + + // 只在值大于0时显示 + return chartUtils.format.autoText(value) + (yUnit ? yUnit : ''); + }) + .each(function(d, i) { + // 为每个标签设置背景矩形的宽度 + const text = d3.select(this); + const textContent = text.text(); + if (textContent) { + const fontSize = text.style("font-size"); + const textWidth = measureTextWidth(textContent, fontSize); + // 获取对应的背景矩形并设置宽度 + const bgRect = d3.select(this.parentNode).selectAll(".value-label-bg").filter((_, j) => j === i); + bgRect.attr("width", textWidth + 10); // 加10px的内边距 + } + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()); + + // 添加X标签到条形图上方 + processedData.forEach(d => { + chartGroup.append("text") + .attr("x", 0) // 与条形图左端对齐 + .attr("y", yScale(d.period) - 10) // 放在条形图上方10px + .style("text-anchor", "start") + .style("fill", "#000000") // 黑色字体 + .style("font-size", "15px") // 15px字体大小 + .style("font-family", typography.label.font_family) + .text(d.period); + }); + + // 移除原始Y轴标签和背景 + yAxis.selectAll(".tick text").remove(); + + let bandWidth = yScale.bandwidth(); + let iconSize = yScale.bandwidth() * 0.7; + + // 在右侧添加图标 + if (jsonData.images) { + chartGroup.selectAll(".icon") + .data(processedData) + .enter() + .append("image") + .attr("class", "icon") + .attr("x", chartWidth + 10) // 放在条形图右侧 + .attr("y", d => yScale(d.period) + (yScale.bandwidth() - iconSize) / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", d => jsonData.images.field[d.period]); + } + + const roughness = 1; + const bowing = 1; + const fillStyle = "hachure"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + + // 移除图例部分 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_12.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_12.js new file mode 100644 index 0000000000000000000000000000000000000000..483ecb31e62bfd78a4b3565a4e9a5c94405dacf9 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_12.js @@ -0,0 +1,362 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_12", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js Horizontal Stacked Bar Chart plain chart#2（圆角） +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + +// 提取数据和配置 +const jsonData = data; // 完整的JSON数据对象 +const chartData = jsonData.data.data; // 实际数据点数组 +const variables = jsonData.variables || {}; // 图表配置 +const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } +}; +const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } +}; // 颜色设置 +const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + +// 添加数值格式化函数 + +// 设置视觉效果变量的默认值 +variables.has_shadow = variables.has_shadow || false; +variables.has_stroke = variables.has_stroke || false; + +// 清空容器 +d3.select(containerSelector).html(""); + +// ---------- 2. 尺寸和布局设置 ---------- + +// 设置图表总尺寸 +const width = variables.width || 600; +const height = variables.height || 400; + +// 设置边距 +const margin = { + top: 50, + right: 30, + bottom: 80, + left: 200 +}; + +// 计算实际绘图区域大小 +const chartWidth = width - margin.left - margin.right; +const chartHeight = height - margin.top - margin.bottom; + +// ---------- 3. 提取字段名和单位 ---------- + +// 根据数据列获取字段名 +const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; +const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; +const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + +// 获取字段单位（如果存在） +let xUnit = ""; +let yUnit = ""; +let groupUnit = ""; + +if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; +} + +if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; +} + +if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; +} + +// ---------- 4. 数据处理 ---------- + +// 获取所有唯一的组值 +const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + +// 处理数据为堆叠格式 +const groupedData = d3.group(chartData, d => d[xField]); +const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; +}); + +// 创建堆叠生成器 +const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + +// 生成堆叠数据 +const stackedData = stack(processedData); + +// ---------- 5. 创建比例尺 ---------- + +// Y轴比例尺 - 使用时间段作为分类 +const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.3); + +// X轴比例尺 - 使用数值 +const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, chartWidth]) + .nice(); + +const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + + +// ---------- 6. 创建SVG容器 ---------- + +const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + +// 添加图表主体容器 +const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + +// ---------- 7. 绘制图表元素 ---------- + +// 绘制堆叠的条形 +const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + +layers.selectAll("path") + .data(d => d) + .enter().append("path") + .attr("d", d => { + const xPos = xScale(d[0]); + const yPos = yScale(d.data.period); + const segmentWidth = xScale(d[1]) - xScale(d[0]); + const barHeight = yScale.bandwidth(); + const isRightmost = Math.abs(d[1] - d.data.total) < 1e-9; // Epsilon for float comparison + + if (segmentWidth <= 1e-9) return ""; // 避免绘制零宽度或负宽度段 + + if (isRightmost) { + // 对于最右侧的段，总是尝试绘制右侧半圆形（或适应的椭圆弧） + return createRightSemicirclePath(xPos, yPos, segmentWidth, barHeight, barHeight / 2); + } else { + // 内部段或太窄的最右段的标准矩形 + return `M${xPos},${yPos} L${xPos + segmentWidth},${yPos} L${xPos + segmentWidth},${yPos + barHeight} L${xPos},${yPos + barHeight} Z`; + } + }) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + +// 添加数值标注 +layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const formattedText = `${chartUtils.format.autoText(value)}${yUnit}`; + const textwidth = measureTextWidth(formattedText, typography.annotation.font_size); + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formattedText : ''; + }); + +// 添加X轴 +const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + +// 添加Y轴 +const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()) +yAxis.selectAll("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + +let bandWidth = yScale.bandwidth() +let iconSize = yScale.bandwidth()*0.7 +let iconPadding = 10; +// 添加文本和图标 +yAxis.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + if(jsonData.images && jsonData.images.field[d]) { + tick.append("image") + .attr("x", - iconSize - iconPadding) // 10是原有的padding + .attr("y", -iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[d]); + tick.select("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("x", -iconSize-2*iconPadding) + } +}); + +// 辅助函数：获取文本宽度 +function measureTextWidth(text, fontFamily, fontSize, fontWeight) { + return chartUtils.text.measure(svg, text, { fontFamily: fontFamily, fontSize: fontSize, fontWeight: fontWeight }).width; +} + +// 水平条形图右侧半圆路径生成函数 +function createRightSemicirclePath(x, y, barWidth, barHeight, radius) { + // x, y: bar的左上角坐标 + // barWidth: bar的宽度 + // barHeight: bar的高度 + // radius: 半圆的半径 (通常是 barHeight / 2) + + if (barWidth <= 1e-9) return ""; // 避免绘制零宽度或负宽度段 + + if (barWidth >= radius) { + // 宽度足以容纳一个矩形部分和一个完整的半圆 + const rectPartWidth = barWidth - radius; + return `M${x},${y}` + // 移动到左上角 + `L${x + rectPartWidth},${y}` + // 画到矩形部分的右上角 + `A${radius},${radius} 0 0,1 ${x + rectPartWidth},${y + barHeight}` + // 画右侧半圆弧 + `L${x},${y + barHeight}` + // 画到底部左边 + `Z`; // 关闭路径 + } else { + // barWidth < radius. 条形太窄，无法形成完整的半圆。 + // 右端将是一个椭圆弧。x方向的"半径"是barWidth，y方向的"半径"是radius (barHeight / 2)。 + const arcRx = barWidth; + const arcRy = radius; // 等于 barHeight / 2 + + // 画一个向右凸出的椭圆弧，从左上角到左下角，最右端到达 x + barWidth + return `M${x},${y}` + // 从左上角开始 + `A${arcRx},${arcRy} 0 1,1 ${x},${y + barHeight}` + // 画大弧，向右凸出 + `Z`; // 关闭路径 + } +} + +/* ============ 4. 添加动态图例 ============ */ +// 支持图例换行并且居中，并且能够让图例刚好在chart上方 +if (groups && groups.length > 0) { + const legendMarkerWidth = 12; // 图例标记宽度 + const legendMarkerHeight = 12; // 图例标记高度 + const legendMarkerRx = 3; // 图例标记圆角X + const legendPadding = 6; // 图例标记和文本之间的间距 + const legendInterItemSpacing = 12; // 图例项之间的水平间距 + + const legendFontFamily = typography.label.font_family || 'Arial'; // 图例字体 + const legendFontSize = parseFloat(typography.label.font_size || '11'); // 图例字号 + const legendFontWeight = typography.label.font_weight || 'normal'; // 图例字重 + const primaryColor = colorResolver.other("primary", { fallback: "#F7941D" }).value; + const availableWidthForLegendWrapping = chartWidth; + const itemMaxHeight = Math.max(legendMarkerHeight, legendFontSize); // 单行图例内容的最大高度 + const legendOptions = { + color: group => colorResolver.field(group, 0, { fallback: primaryColor }).value, + markerShape: "rect", + markerWidth: legendMarkerWidth, + markerHeight: legendMarkerHeight, + markerSize: legendMarkerWidth, + markerRadius: legendMarkerRx, + markerOpacity: 0.85, + labelGap: legendPadding, + itemGap: legendInterItemSpacing, + rowGap: 6, + itemHeight: itemMaxHeight, + itemPaddingEnd: 0, + maxWidth: availableWidthForLegendWrapping, + align: "center", + fontFamily: legendFontFamily, + fontSize: legendFontSize, + fontWeight: legendFontWeight, + textColor: "#333", + className: "custom-legend-container", + }; + const legendLayout = chartUtils.legend.layout(groups, { ...legendOptions, context: svg }); + + if (legendLayout.items.length > 0) { + const paddingBelowLegendToChart = 15; // 图例块底部与图表顶部的间距 + const minSvgGlobalTopPadding = 15; // SVG顶部到图例块的最小间距 + + let legendBlockStartY = margin.top - paddingBelowLegendToChart - legendLayout.height; + legendBlockStartY = Math.max(minSvgGlobalTopPadding, legendBlockStartY); // 确保不超出SVG顶部 + + chartUtils.legend.draw(svg, groups, { + ...legendOptions, + x: (width - availableWidthForLegendWrapping) / 2, + y: legendBlockStartY, + }); + + // 添加字段名称 - 居中于图例上方 + svg.append("text") + .attr("x", width / 2) + .attr("y", legendBlockStartY - 10) // 放在图例上方，保持间距 + .attr("text-anchor", "middle") + .attr("dominant-baseline", "alphabetic") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + } +} + +return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2.js new file mode 100644 index 0000000000000000000000000000000000000000..fa1262029859c68fad7fcc5a38318b2417b2db78 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2.js @@ -0,0 +1,747 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_2", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 根据条形高度计算icon尺寸（便于其他模板复制复用） + const calcIconSize = (barHeight, options = {}) => { + const maxSize = typeof options.maxSize === "number" ? options.maxSize : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(maxSize, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算）（便于其他模板复制复用） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; // 图表总宽度 + const height = variables.height; // 图表总高度 + // 边距：top-顶部，right-右侧，bottom-底部，left-左侧 + const margin = { top: 80, right: 160, bottom: 40, left: 60 }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 提取字段名称 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 获取所有字段的单位（如果存在且不是"none"） + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + const groupUnit = groupChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 找到要用的两个数据组（排除Total Paid Leave，因为它在图中不显示为单独的条） + const displayGroups = groups.filter(g => g !== "Total Paid Leave"); + const firstGroup = displayGroups[0]; // 第一组（通常是年假） + const secondGroup = displayGroups[1]; // 第二组（通常是公共假期） + + // 计算每个维度的总值，用于排序 + const dimensionTotals = {}; + allDimensions.forEach(dimension => { + let total = 0; + displayGroups.forEach(group => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension && d[groupField] === group); + if (dataPoint) { + total += +dataPoint[valueField]; + } + }); + dimensionTotals[dimension] = total; + }); + + // 按总值降序排序维度 + const dimensions = [...allDimensions].sort((a, b) => { + // 先按总值排序 + const diff = dimensionTotals[b] - dimensionTotals[a]; + if (diff !== 0) return diff; + + // 如果总值相同，按字母顺序排序 + return String(a).localeCompare(String(b)); + }); + + // ---------- 5. 布局计算和字体调整 ---------- + + const textPadding = 5; + const maxIconSize = 30; + const barPadding = variables.has_spacing ? 0.3 : 0.2; + const dimLabelMaxWidth = width * 0.25; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + const flagPadding = 5; + const legendSquareSize = 12; + const legendSpacing = 5; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + // Y轴比例尺（用于维度）- 先创建，后面会更新range + let yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const rowHeight = yScale.bandwidth(); + + // icon尺寸（按rowHeight动态） + const iconSize = calcIconSize(rowHeight, { maxSize: maxIconSize, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: rowHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算组标签宽度，用于图例 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + let maxGroupWidth = 0; + displayGroups.forEach(group => { + const formattedGroup = groupUnit ? + `${group}${groupUnit}` : + `${group}`; + + const textWidth = chartUtils.text.measure(tempSvg, formattedGroup, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + tempSvg.remove(); + + // 调整左侧边距 + margin.left = maxLabelWidth + flagPadding + flagWidth + 20; + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // 更新yScale的range + yScale.range([0, innerHeight]); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色辅助函数 + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // 添加阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + displayGroups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + } + chartUtils.legend.row(svg, [firstGroup, secondGroup], { + colorResolver, + colors, + color: group => getColor(group), + }, { + x: margin.left, + y: margin.top - 20, + maxWidth: innerWidth + margin.right - 20, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerSize: legendSquareSize, + labelGap: legendSpacing, + itemGap: legendSpacing, + }); + + // ---------- 8. 创建主绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 创建比例尺 ---------- + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 计算最大总值 + const maxTotal = d3.max(Object.values(dimensionTotals)); + + // X轴比例尺（用于数值） - 使用更多的可用空间，只保留5%的右侧边距 + const xScale = d3.scaleLinear() + .domain([0, maxTotal * 1.05]) + .range([0, innerWidth]); + + // ---------- 10. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // ---------- 11. 绘制条形图和标签 ---------- + + // 创建临时SVG元素用于测量文本宽度 (在循环外部创建，提高效率) + const tempTextSvg = svg.append("g") + .attr("visibility", "hidden"); + + // 估算标签宽度的函数 + const estimateLabelWidth = (text) => { + return chartUtils.text.measure(tempTextSvg, text, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + }; + + // 格式化函数 + const formatValueWithUnit = (value) => { + return `${chartUtils.format.autoText(value)}${valueUnit}`; + }; + + // 标签内边距 + const labelPadding = 5; + + // 绘制条形和标签 + dimensions.forEach((dimension, dimIndex) => { + // 当前行的Y位置 + const barY = yScale(dimension); + const barHeight = yScale.bandwidth(); + const centerY = barY + barHeight / 2; // 垂直居中位置 + + // 获取数据点 + const firstGroupData = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === firstGroup); + const secondGroupData = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === secondGroup); + + // 绘制图标和维度标签 + const flagX = -flagWidth - flagPadding - 5; + const textX = flagX - 5; + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", textX) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", textX) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 初始化条形宽度和位置 + let firstBarWidth = 0; + let secondBarWidth = 0; + let totalBarWidth = 0; + let xPos = 0; // 当前绘制位置 + + // 用于记录外部标签信息 + let firstLabelIsOutside = false; + let firstLabelOutsideX = 0; + let firstLabelOutsideWidth = 0; + + // 绘制第一组条形和标签 + if (firstGroupData) { + firstBarWidth = xScale(+firstGroupData[valueField]); + totalBarWidth += firstBarWidth; + + // 绘制条形 + g.append("rect") + .attr("x", xPos) + .attr("y", barY) + .attr("width", firstBarWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${firstGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(firstGroup)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + // 移除 hover 效果，避免干扰 + // .on("mouseover", function() { d3.select(this).attr("opacity", 0.8); }) + // .on("mouseout", function() { d3.select(this).attr("opacity", 1); }); + + // 处理第一组标签 + const labelText = formatValueWithUnit(+firstGroupData[valueField]); + const labelWidth = estimateLabelWidth(labelText); + let labelX, labelColor, textAnchor; + + let label_size = typography.annotation.font_size; + if (firstBarWidth < labelWidth) { + label_size = label_size * (firstBarWidth / labelWidth); + } + // 内部居中 + labelX = xPos + firstBarWidth / 2; + labelColor = "#ffffff"; + textAnchor = "middle"; + firstLabelIsOutside = false; + + // 绘制标签 (如果放在外部，暂时不绘制，等第二组处理完一起绘制外部标签) + if (!firstLabelIsOutside) { + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", label_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + } + + // 更新X位置 + xPos += firstBarWidth; + } + + // 绘制第二组条形和标签 + if (secondGroupData) { + secondBarWidth = xScale(+secondGroupData[valueField]); + totalBarWidth += secondBarWidth; + + // 绘制条形 + g.append("rect") + .attr("x", xPos) // 从第一组结束的位置开始 + .attr("y", barY) + .attr("width", secondBarWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${secondGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(secondGroup)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + // .on("mouseover", function() { d3.select(this).attr("opacity", 0.8); }) + // .on("mouseout", function() { d3.select(this).attr("opacity", 1); }); + + // 处理第二组标签 + const labelText = formatValueWithUnit(+secondGroupData[valueField]); + const labelWidth = estimateLabelWidth(labelText); + let labelX, labelColor, textAnchor; + + if (secondBarWidth >= labelWidth + 2 * labelPadding) { + // 内部居中 + labelX = xPos + secondBarWidth / 2; // 在第二段内部居中 + labelColor = "#ffffff"; + textAnchor = "middle"; + + // 绘制标签 + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + + } else { + // 外部放置 + if (firstLabelIsOutside) { + // 如果第一组也在外部，放在第一组外部标签的右侧 + labelX = firstLabelOutsideX + firstLabelOutsideWidth + labelPadding; + } else { + // 否则，放在总条形的右侧 + labelX = totalBarWidth + labelPadding; + } + labelColor = colorResolver.text({ fallback: "#333333" }).value; + textAnchor = "start"; + + // 绘制标签 + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + } + } + + // 现在绘制可能被延迟的第一组外部标签 + if (firstLabelIsOutside) { + g.append("text") + .attr("x", firstLabelOutsideX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 外部标签始终左对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 外部标签用默认色 + .text(formatValueWithUnit(+firstGroupData[valueField])); // 获取文本 + } + + }); + + // 移除临时SVG元素 + tempTextSvg.remove(); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..2daf3a7a96ca7512ff60a6842313e4918ab47418 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_2_hand.js @@ -0,0 +1,733 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_2_hand", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 2]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // 根据条形高度计算icon尺寸 + const calcIconSize = (barHeight, options = {}) => { + const max = typeof options.max === "number" ? options.max : 30; + const minRatio = typeof options.minRatio === "number" ? options.minRatio : 0.8; + const minPx = typeof options.minPx === "number" ? options.minPx : 10; + const size = Math.min(max, Math.max(barHeight * minRatio, minPx)); + return { width: size, height: size }; + }; + + // 计算类别label布局（统一字号+智能换行+测宽+margin.left计算） + const buildDimLabelLayout = (params) => { + const { + containerSelector, + labels, + fontConfig, + maxWidth, + maxHeight, + lineSpacing, + targetFontSize + } = params; + + const tempMeasureSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + const measureWidth = (text, fontSize) => chartUtils.text.measure(tempMeasureSvg, text, { + fontFamily: fontConfig.font_family, + fontSize, + fontWeight: fontConfig.font_weight + }).width; + + const breakLongWord = (word, maxWidth, fontSize) => { + const lines = []; + let currentLine = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testWithChar = currentLine + char; + const testWithHyphen = currentLine + "-"; + if (measureWidth(testWithChar, fontSize) > maxWidth && currentLine !== "") { + lines.push(testWithHyphen); + currentLine = char; + } else { + currentLine = testWithChar; + } + } + if (currentLine !== "") lines.push(currentLine); + return lines.length > 0 ? lines : [word]; + }; + + const breakWordIntoCurrentLine = (currentLine, word, maxWidth, fontSize) => { + const completedLines = []; + let chars = ""; + for (let i = 0; i < word.length; i++) { + const char = word[i]; + const testLine = currentLine + chars + char; + const testLineWithHyphen = currentLine + chars + "-"; + if (measureWidth(testLine, fontSize) > maxWidth) { + if (chars === "") { + completedLines.push(currentLine); + const brokenLines = breakLongWord(word, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + completedLines.push(testLineWithHyphen); + const remaining = word.substring(i); + const remainingWidth = measureWidth(remaining, fontSize); + if (remainingWidth > maxWidth) { + const brokenLines = breakLongWord(remaining, maxWidth, fontSize); + return { + completedLines: [...completedLines, ...brokenLines.slice(0, -1)], + remaining: brokenLines[brokenLines.length - 1] + }; + } + return { completedLines, remaining }; + } + chars += char; + } + return { completedLines, remaining: currentLine + chars }; + }; + + const wrapSmart = (text, maxWidth, fontSize) => { + const words = String(text || "").split(/\s+/).filter(w => w !== ""); + if (words.length === 0) return [String(text || "")]; + + const lines = []; + let currentLine = ""; + + for (let i = 0; i < words.length; i++) { + const word = words[i]; + const separator = currentLine === "" ? "" : " "; + const testLine = currentLine + separator + word; + if (measureWidth(testLine, fontSize) <= maxWidth) { + currentLine = testLine; + continue; + } + + if (currentLine === "") { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + continue; + } + + const utilization = measureWidth(currentLine, fontSize) / maxWidth; + if (utilization < 0.5) { + const result = breakWordIntoCurrentLine(currentLine, word, maxWidth, fontSize); + lines.push(...result.completedLines); + currentLine = result.remaining; + continue; + } + + lines.push(currentLine); + if (measureWidth(word, fontSize) > maxWidth) { + const broken = breakLongWord(word, maxWidth, fontSize); + lines.push(...broken.slice(0, -1)); + currentLine = broken[broken.length - 1]; + } else { + currentLine = word; + } + } + + if (currentLine !== "") lines.push(currentLine); + + const out = [...lines]; + for (let i = 1; i < out.length; i++) { + const prevTrim = (out[i - 1] || "").trimEnd(); + if (!prevTrim.endsWith("-")) continue; + + const curTrim = String(out[i] || "").trim(); + const match = curTrim.match(/^([A-Za-z])(\s+.*)?$/); + if (!match) continue; + + const firstLetter = match[1]; + const rest = (match[2] || "").trimStart(); + const candidatePrev = prevTrim.slice(0, -1) + firstLetter; + if (measureWidth(candidatePrev, fontSize) > maxWidth) continue; + + out[i - 1] = candidatePrev; + if (rest === "") { + out.splice(i, 1); + i -= 1; + } else { + out[i] = rest; + } + } + + return out.length > 0 ? out : [String(text || "")]; + }; + + const fitsAll = (fontSize) => { + const lineHeight = fontSize * lineSpacing; + for (let i = 0; i < labels.length; i++) { + const labelText = String(labels[i] || ""); + const lines = wrapSmart(labelText, maxWidth, fontSize); + const totalHeight = (lines.length <= 1) + ? fontSize + : ((lines.length - 1) * lineHeight + fontSize); + if (totalHeight > maxHeight) return false; + } + return true; + }; + + let low = 1; + let high = targetFontSize; + for (let i = 0; i < 18; i++) { + const mid = (low + high) / 2; + if (fitsAll(mid)) low = mid; + else high = mid; + } + + const bestFontSize = low; + const lineHeight = bestFontSize * lineSpacing; + const dimLabelConfig = {}; + let maxLabelWidth = 0; + + for (let i = 0; i < labels.length; i++) { + const label = labels[i]; + const labelText = String(label || ""); + const lines = wrapSmart(labelText, maxWidth, bestFontSize); + dimLabelConfig[label] = { + fontSize: bestFontSize, + lineHeight: lineHeight, + lines: lines, + needsWrapping: lines.length > 1 + }; + for (let j = 0; j < lines.length; j++) { + maxLabelWidth = Math.max(maxLabelWidth, measureWidth(lines[j], bestFontSize)); + } + } + + tempMeasureSvg.remove(); + return { dimLabelConfig, maxLabelWidth, fontSize: bestFontSize, lineHeight }; + }; + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; + const height = variables.height; + const margin = { top: 80, right: 160, bottom: 40, left: 60 }; + + // ---------- 3. 提取字段名和单位 ---------- + + // 提取字段名称 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 获取所有字段的单位（如果存在且不是"none"） + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + const groupUnit = groupChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 找到要用的两个数据组（排除Total Paid Leave，因为它在图中不显示为单独的条） + const displayGroups = groups.filter(g => g !== "Total Paid Leave"); + const firstGroup = displayGroups[0]; // 第一组（通常是年假） + const secondGroup = displayGroups[1]; // 第二组（通常是公共假期） + + // 计算每个维度的总值，用于排序 + const dimensionTotals = {}; + allDimensions.forEach(dimension => { + let total = 0; + displayGroups.forEach(group => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension && d[groupField] === group); + if (dataPoint) { + total += +dataPoint[valueField]; + } + }); + dimensionTotals[dimension] = total; + }); + + // 按总值降序排序维度 + const dimensions = [...allDimensions].sort((a, b) => { + // 先按总值排序 + const diff = dimensionTotals[b] - dimensionTotals[a]; + if (diff !== 0) return diff; + + // 如果总值相同，按字母顺序排序 + return String(a).localeCompare(String(b)); + }); + + // ---------- 5. 布局计算和字体调整 ---------- + + const dimLabelMaxWidth = width * 0.2; + const dimLabelLineSpacing = 1.01; + const targetLabelFontSize = parseFloat(typography.label.font_size) || 12; + + // 计算内部绘图区域尺寸（初始值） + let innerWidth = width - margin.left - margin.right; + let innerHeight = height - margin.top - margin.bottom; + + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(barPadding); + + const barHeight = yScale.bandwidth(); + + // 调用智能换行布局计算 + const dimLabelResult = buildDimLabelLayout({ + containerSelector: containerSelector, + labels: dimensions, + fontConfig: typography.label, + maxWidth: dimLabelMaxWidth, + maxHeight: barHeight, + lineSpacing: dimLabelLineSpacing, + targetFontSize: targetLabelFontSize + }); + + const { dimLabelConfig, maxLabelWidth } = dimLabelResult; + + // 计算icon尺寸 + const iconSize = calcIconSize(barHeight, { max: 30, minRatio: 0.8, minPx: 10 }); + const flagWidth = iconSize.width; + const flagHeight = iconSize.height; + const flagPadding = 5; + + // 根据标签宽度和icon宽度调整左边距 + margin.left = flagWidth + flagPadding + maxLabelWidth + 15; + + // 图例方块尺寸 + const legendSquareSize = 12; + const legendSpacing = 5; + + // 重新计算内部绘图区域尺寸 + innerWidth = width - margin.left - margin.right; + innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色辅助函数 + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // 添加阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + displayGroups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + } + chartUtils.legend.row(svg, [firstGroup, secondGroup], { + colorResolver, + colors, + color: group => getColor(group), + }, { + x: margin.left, + y: margin.top - 20, + maxWidth: innerWidth + margin.right - 20, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerSize: legendSquareSize, + labelGap: legendSpacing, + itemGap: legendSpacing, + }); + + // ---------- 8. 创建主绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 创建比例尺 ---------- + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 计算最大总值 + const maxTotal = d3.max(Object.values(dimensionTotals)); + + // X轴比例尺（用于数值） - 使用更多的可用空间，只保留5%的右侧边距 + const xScale = d3.scaleLinear() + .domain([0, maxTotal * 1.05]) + .range([0, innerWidth]); + + // ---------- 10. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension)) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // ---------- 11. 绘制条形图和标签 ---------- + + // 创建临时SVG元素用于测量文本宽度 (在循环外部创建，提高效率) + const tempTextSvg = svg.append("g") + .attr("visibility", "hidden"); + + // 估算标签宽度的函数 + const estimateLabelWidth = (text) => { + return chartUtils.text.measure(tempTextSvg, text, { + fontFamily: typography.annotation.font_family, + fontSize: typography.annotation.font_size, + fontWeight: typography.annotation.font_weight + }).width; + }; + + // 标签内边距 + const labelPadding = 5; + + // 绘制条形和标签 + dimensions.forEach((dimension, dimIndex) => { + // 当前行的Y位置 + const barY = yScale(dimension); + const barHeight = yScale.bandwidth(); + const centerY = barY + barHeight / 2; + + // 获取数据点 + const firstGroupData = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === firstGroup); + const secondGroupData = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === secondGroup); + + // 绘制图标和维度标签 + const flagX = -flagWidth - flagPadding - 5; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", flagX) + .attr("y", centerY - flagHeight / 2) + .attr("width", flagWidth) + .attr("height", flagHeight) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签（支持多行） + const labelConfig = dimLabelConfig[dimension]; + const labelGroup = g.append("text") + .attr("x", flagX - 5) + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", `${labelConfig.fontSize}px`) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + if (labelConfig.needsWrapping) { + const lineHeight = labelConfig.lineHeight; + const startY = centerY - ((labelConfig.lines.length - 1) * lineHeight) / 2; + labelGroup.attr("y", startY); + + labelConfig.lines.forEach((line, i) => { + labelGroup.append("tspan") + .attr("x", flagX - 5) + .attr("dy", i === 0 ? "0.35em" : `${lineHeight}`) + .text(line); + }); + } else { + labelGroup + .attr("y", centerY) + .attr("dy", "0.35em") + .text(labelConfig.lines[0]); + } + + // 初始化条形宽度和位置 + let firstBarWidth = 0; + let secondBarWidth = 0; + let totalBarWidth = 0; + let xPos = 0; // 当前绘制位置 + + // 用于记录外部标签信息 + let firstLabelIsOutside = false; + let firstLabelOutsideX = 0; + let firstLabelOutsideWidth = 0; + + // 绘制第一组条形和标签 + if (firstGroupData) { + firstBarWidth = xScale(+firstGroupData[valueField]); + totalBarWidth += firstBarWidth; + + // 绘制条形 + g.append("rect") + .attr("x", xPos) + .attr("y", barY) + .attr("width", firstBarWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${firstGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(firstGroup)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + // 移除 hover 效果，避免干扰 + // .on("mouseover", function() { d3.select(this).attr("opacity", 0.8); }) + // .on("mouseout", function() { d3.select(this).attr("opacity", 1); }); + + // 处理第一组标签 + const labelText = chartUtils.format.autoText(firstGroupData[valueField]); + const labelWidth = estimateLabelWidth(labelText); + let labelX, labelColor, textAnchor; + + let label_size = typography.annotation.font_size; + if (firstBarWidth < labelWidth) { + label_size = label_size * (firstBarWidth / labelWidth); + } + // 内部居中 + labelX = xPos + firstBarWidth / 2; + labelColor = "#ffffff"; + textAnchor = "middle"; + firstLabelIsOutside = false; + + // 绘制标签 (如果放在外部，暂时不绘制，等第二组处理完一起绘制外部标签) + if (!firstLabelIsOutside) { + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", label_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + } + + // 更新X位置 + xPos += firstBarWidth; + } + + // 绘制第二组条形和标签 + if (secondGroupData) { + secondBarWidth = xScale(+secondGroupData[valueField]); + totalBarWidth += secondBarWidth; + + // 绘制条形 + g.append("rect") + .attr("x", xPos) // 从第一组结束的位置开始 + .attr("y", barY) + .attr("width", secondBarWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${secondGroup.replace(/\s+/g, '-').toLowerCase()})` : + getColor(secondGroup)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + // .on("mouseover", function() { d3.select(this).attr("opacity", 0.8); }) + // .on("mouseout", function() { d3.select(this).attr("opacity", 1); }); + + // 处理第二组标签 + const labelText = chartUtils.format.autoText(secondGroupData[valueField]); + const labelWidth = estimateLabelWidth(labelText); + let labelX, labelColor, textAnchor; + + if (secondBarWidth >= labelWidth + 2 * labelPadding) { + // 内部居中 + labelX = xPos + secondBarWidth / 2; // 在第二段内部居中 + labelColor = "#ffffff"; + textAnchor = "middle"; + + // 绘制标签 + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + + } else { + // 外部放置 + if (firstLabelIsOutside) { + // 如果第一组也在外部，放在第一组外部标签的右侧 + labelX = firstLabelOutsideX + firstLabelOutsideWidth + labelPadding; + } else { + // 否则，放在总条形的右侧 + labelX = totalBarWidth + labelPadding; + } + labelColor = colorResolver.text({ fallback: "#333333" }).value; + textAnchor = "start"; + + // 绘制标签 + g.append("text") + .attr("x", labelX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", textAnchor) + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", labelColor) + .text(labelText); + } + } + + // 现在绘制可能被延迟的第一组外部标签 + if (firstLabelIsOutside) { + g.append("text") + .attr("x", firstLabelOutsideX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 外部标签始终左对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 外部标签用默认色 + .text(chartUtils.format.autoText(firstGroupData[valueField])); // 获取文本 + } + + }); + + // 移除临时SVG元素 + tempTextSvg.remove(); + const roughness = 1; + const bowing = 1; + const fillStyle = "solid"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_3.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_3.js new file mode 100644 index 0000000000000000000000000000000000000000..acb332e17b86301870f1d74c25420432685dd51f --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_3.js @@ -0,0 +1,480 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_3", + "is_composite": true, + "required_fields": ["x", "y", "y2", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["numerical"],["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["radius_corner", "spacing", "shadow", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "replace", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图与比例圆复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "24px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "14px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#1E88E5" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; + variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; + variables.has_gradient = variables.has_gradient !== undefined ? variables.has_gradient : false; + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // 设置边距 + const margin = { + top: 90, // 顶部留出标题空间 + right: 5, // 右侧边距 + bottom: 40, // 底部边距 + left: 60 // 左侧边距，给图标和文字留出空间 + }; + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + const totalField = chartUtils.schema.channel(jsonData, "y2").key || "total"; + + // 获取字段描述用于右侧圆圈图标题 + const totalFieldDescription = totalField; + + // 获取字段单位 + let valueUnit = ""; + let totalUnit = ""; + valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + totalUnit = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 为排序和圆形图准备数据 + const firstGroupValues = {}; // 存储第一个分组值（用于排序） + const dimensionCircleTotals = {}; // 存储圆形图数据 + + // 获取所有分组，确保排序一致 + const sortedGroups = [...groups].sort((a, b) => String(a).localeCompare(String(b))); + const primaryGroup = sortedGroups[0]; // 使用第一个分组值排序 + + // 为每个维度获取第一个分组的值和圆形图数据 + dimensions.forEach(dimension => { + // 找到该维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + // 获取第一个分组的值（用于排序） + const primaryGroupData = dimensionData.find(d => d[groupField] === primaryGroup); + firstGroupValues[dimension] = primaryGroupData && primaryGroupData[valueField] !== undefined ? + +primaryGroupData[valueField] : 0; + + // 获取圆形图的值(y2/totalField) + // 注意：总天数值应该对每个维度只有一个，取第一个有值的数据点 + const totalDaysData = dimensionData.find(d => d[totalField] !== undefined); + dimensionCircleTotals[dimension] = totalDaysData ? +totalDaysData[totalField] : 0; + }); + + // 按第一个分组值降序排序维度 + const sortedDimensions = [...dimensions].sort((a, b) => { + return firstGroupValues[b] - firstGroupValues[a]; + }); + + // 为每个维度准备堆叠数据 + const stackData = {}; + sortedDimensions.forEach(dimension => { + stackData[dimension] = {}; + + let accumulator = 0; + groups.forEach(group => { + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === group); + + if (dataPoint && dataPoint[valueField] !== undefined) { + const value = +dataPoint[valueField]; + stackData[dimension][group] = { + start: accumulator, + end: accumulator + value, + value: value + }; + accumulator += value; + } else { + stackData[dimension][group] = { + start: accumulator, + end: accumulator, + value: 0 + }; + } + }); + + // 添加总计 + stackData[dimension].total = accumulator; + }); + + // ---------- 5. 布局计算 ---------- + + // 设置堆叠条形图和圆形图的布局比例 + const barChartWidthRatio = 0.75; // 堆叠条形图占比 + const circleChartWidthRatio = 0.25; // 圆形图占比 + + // 计算各部分宽度 + const barChartWidth = innerWidth * barChartWidthRatio; + const circleChartWidth = innerWidth * circleChartWidthRatio; + + // ---------- 6. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于堆叠条形图） + const xScale = d3.scaleLinear() + .domain([0, 100]) // 假设堆叠值总和为100% + .range([0, barChartWidth]); + + // 圆形面积比例尺（用于总值） + const maxCircleValue = d3.max(Object.values(dimensionCircleTotals)); + const minRadius = yScale.bandwidth() * 0.1; // 最小半径 + const maxRadius = Math.min(yScale.bandwidth() * 1.0,circleChartWidth*0.5) // 最大半径可以是两个条形的高度 + + const radiusScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxCircleValue]) + .range([minRadius, maxRadius]); + + // ---------- 7. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 8. 添加SVG定义 ---------- + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 为每个组创建渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const barColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group.replace(/\s+/g, '-')}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 9. 不添加标题 ---------- + + // ---------- 10. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 11. 获取颜色的辅助函数 ---------- + + // 获取组的颜色 + const getColor = (group) => { + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + // 如果没有指定颜色，则使用主色或默认颜色 + return colorResolver.other("primary", { fallback: "#1E88E5" }).value; + }; + + // ---------- 12. 添加右侧圆圈图标题 ---------- + + if (totalFieldDescription) { + // 计算标题位置 - 右对齐 + const titleX = width - margin.right; + const titleY = margin.top - 20; // 标题在图表上方 + + svg.append("text") + .attr("x", titleX) + .attr("y", titleY) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(totalFieldDescription); + } + chartUtils.legend.draw(svg, groups, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: margin.left, + y: margin.top - 30, + maxWidth: barChartWidth, + fitToWidth: true, + minFontSize: 8, + markerShape: "rect", + markerSize: 12, + labelGap: 5, + itemGap: 15, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + // ---------- 14. 为每个维度绘制堆叠条形和圆形 ---------- + + sortedDimensions.forEach((dimension, index) => { + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + const centerY = y + barHeight / 2; + + // 1. 添加维度图标（如果有） + const iconSize = Math.min(barHeight * 0.8, 30); + const iconX = -iconSize; // 图标位置 + + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX - iconSize / 2) + .attr("y", centerY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 2. 绘制堆叠条形 + const barSegments = []; // 存储条形段用于后续添加白线 + + groups.forEach((group, groupIndex) => { + if (!stackData[dimension][group]) return; + + const stackItem = stackData[dimension][group]; + const barWidth = xScale(stackItem.value); + const isLastGroup = groupIndex === groups.length - 1; + + // 只绘制有值的部分 + if (stackItem.value > 0) { + // 获取填充颜色（考虑渐变） + const fillColor = variables.has_gradient ? + `url(#bar-gradient-${group.replace(/\s+/g, '-')})` : + getColor(group); + + // 绘制条形 + const barSegment = g.append("rect") + .attr("x", xScale(stackItem.start)) + .attr("y", y) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", fillColor) + .attr("rx", variables.has_rounded_corners ? Math.min(barHeight * 0.2, 5) : 0) + .attr("ry", variables.has_rounded_corners ? Math.min(barHeight * 0.2, 5) : 0) + .style("stroke", variables.has_stroke ? colorResolver.variant(getColor(group), { mode: "darker", amount: 0.5 }) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 存储条形段信息用于后续添加白线 + barSegments.push({ + x: xScale(stackItem.start), + end: xScale(stackItem.start) + barWidth, + y, + height: barHeight + }); + + // 测量标签宽度 + const formattedValue = `${chartUtils.format.autoText(stackItem.value)}${valueUnit}`; + const valueLabelFontSize = `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const labelWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断标签是放在内部还是外部 + const minWidthForLabel = labelWidth + 5; // 确保有足够空间 + + if (barWidth > minWidthForLabel || !isLastGroup) { + // 如果条形宽度足够大或不是最后一组，添加内部标签（右对齐） + g.append("text") + .attr("x", xScale(stackItem.start) + barWidth - 5) // 距离右边缘5px + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色文本更易读 + .text(formattedValue); + } else if (isLastGroup) { + // 如果是最后一组且条形宽度不够，添加外部标签 + g.append("text") + .attr("x", xScale(stackItem.start) + barWidth + 5) // 距离右边缘5px + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐（在条形外部） + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用文本颜色 + .text(formattedValue); + } + } + }); + + // 添加白线分隔相邻的条形段 + for (let i = 1; i < barSegments.length; i++) { + const x = barSegments[i].x; + g.append("line") + .attr("x1", x) + .attr("y1", y) + .attr("x2", x) + .attr("y2", y + barHeight) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1); + } + + // 3. 绘制圆形（显示总值） + const circleValue = dimensionCircleTotals[dimension]; + if (circleValue > 0) { + const circleRadius = radiusScale(circleValue); + const circleX = barChartWidth + circleChartWidth / 2; + + // 绘制圆形 + g.append("circle") + .attr("cx", circleX) + .attr("cy", centerY) + .attr("r", circleRadius) + .attr("fill", colorResolver.other("primary", { fallback: "#1E88E5" }).value) + .style("stroke", "#FFFFFF") + .style("stroke-width", 1.5 ) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 添加总值标签 + const formattedTotal = `${chartUtils.format.autoText(circleValue)}${totalUnit}`; + + // 测量文本宽度以决定放置位置 + const textWidth = chartUtils.text.measure(svg, formattedTotal, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + // 如果圆足够大，将文本放在圆内；否则放在上方 + if (circleRadius * 2 > textWidth + 10) { + g.append("text") + .attr("x", circleX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") + .text(formattedTotal); + } else { + g.append("text") + .attr("x", circleX) + .attr("y", centerY - circleRadius - 5) + .attr("dy", "0em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedTotal); + } + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_4.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_4.js new file mode 100644 index 0000000000000000000000000000000000000000..004d9684da12a2c05920843ff40c10bbb3c2d03e --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_4.js @@ -0,0 +1,512 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_4", + "is_composite": true, + "required_fields": ["x", "y", "y2", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["numerical"],["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [0, "inf"], [2, 5]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary"], + "supported_effects": ["radius_corner", "spacing", "shadow", "gradient", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "replace", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图与比例正方形复合图表实现 - 使用D3.js +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "24px", font_weight: 700 }, + label: { font_family: "Arial", font_size: "14px", font_weight: 500 }, + description: { font_family: "Arial", font_size: "16px", font_weight: 500 }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: 400 } + }; + const colors = jsonData.colors || { + text_color: "#000000", + background_color: "#FFFFFF", + other: { primary: "#1E88E5" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图像设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + const titles = jsonData.titles || {}; // 标题配置 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_rounded_corners = variables.has_rounded_corners !== undefined ? variables.has_rounded_corners : false; + variables.has_spacing = variables.has_spacing !== undefined ? variables.has_spacing : false; + variables.has_shadow = variables.has_shadow !== undefined ? variables.has_shadow : false; + variables.has_gradient = variables.has_gradient !== undefined ? variables.has_gradient : false; + variables.has_stroke = variables.has_stroke !== undefined ? variables.has_stroke : false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 800; + const height = variables.height || 600; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列提取字段名 + const dimensionField = chartUtils.schema.channel(jsonData, "x").key || "dimension"; + const valueField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + const totalField = chartUtils.schema.channel(jsonData, "y2").key || "total"; + + // 获取字段描述用于右侧圆圈图标题 + const totalFieldDescription = totalField; + + // 获取字段单位 + let valueUnit = ""; + let totalUnit = ""; + valueUnit = chartUtils.schema.channel(jsonData, "y").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y").unit; + totalUnit = chartUtils.schema.channel(jsonData, "y2").unit === "none" ? "" : + chartUtils.schema.channel(jsonData, "y2").unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const dimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 为排序和圆形图准备数据 + const firstGroupValues = {}; // 存储第一个分组值（用于排序） + const dimensionCircleTotals = {}; // 存储圆形图数据 + + // 获取所有分组，确保排序一致 + const sortedGroups = [...groups].sort((a, b) => String(a).localeCompare(String(b))); + const primaryGroup = sortedGroups[0]; // 使用第一个分组值排序 + + // 为每个维度获取第一个分组的值和圆形图数据 + dimensions.forEach(dimension => { + // 找到该维度下的所有数据点 + const dimensionData = chartData.filter(d => d[dimensionField] === dimension); + + // 获取第一个分组的值（用于排序） + const primaryGroupData = dimensionData.find(d => d[groupField] === primaryGroup); + firstGroupValues[dimension] = primaryGroupData && primaryGroupData[valueField] !== undefined ? + +primaryGroupData[valueField] : 0; + + // 获取圆形图的值(y2/totalField) + // 注意：总天数值应该对每个维度只有一个，取第一个有值的数据点 + const totalDaysData = dimensionData.find(d => d[totalField] !== undefined); + dimensionCircleTotals[dimension] = totalDaysData ? +totalDaysData[totalField] : 0; + }); + + // 按第一个分组值降序排序维度 + const sortedDimensions = [...dimensions].sort((a, b) => { + return firstGroupValues[b] - firstGroupValues[a]; + }); + + // 为每个维度准备堆叠数据 + const stackData = {}; + sortedDimensions.forEach(dimension => { + stackData[dimension] = {}; + + let accumulator = 0; + groups.forEach(group => { + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === group); + + if (dataPoint && dataPoint[valueField] !== undefined) { + const value = +dataPoint[valueField]; + stackData[dimension][group] = { + start: accumulator, + end: accumulator + value, + value: value + }; + accumulator += value; + } else { + stackData[dimension][group] = { + start: accumulator, + end: accumulator, + value: 0 + }; + } + }); + + // 添加总计 + stackData[dimension].total = accumulator; + }); + + // ---------- 5. 计算左侧标签所需空间 ---------- + + // 创建临时SVG来计算维度标签宽度 + const tempSvg = d3.select(containerSelector) + .append("svg") + .attr("width", 0) + .attr("height", 0) + .style("visibility", "hidden"); + + // 计算最长维度名称的宽度 + let maxLabelWidth = 0; + sortedDimensions.forEach(dimension => { + const textWidth = chartUtils.text.measure(tempSvg, dimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + maxLabelWidth = Math.max(maxLabelWidth, textWidth); + }); + + // 设置边距，确保左侧有足够空间放置维度标签 + // 添加一些额外空间作为标签和条形图之间的间距 + const labelMargin = 5; + const margin = { + top: 90, // 顶部留出标题空间 + right: 5, // 右侧边距 + bottom: 40, // 底部边距 + left: maxLabelWidth + labelMargin // 左侧边距，为维度标签预留空间 + }; + + // 计算内部绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 6. 布局计算 ---------- + + // 设置堆叠条形图和圆形图的布局比例 + const barChartWidthRatio = 0.75; // 堆叠条形图占比 + const circleChartWidthRatio = 0.25; // 圆形图占比 + + // 计算各部分宽度 + const barChartWidth = innerWidth * barChartWidthRatio; + const circleChartWidth = innerWidth * circleChartWidthRatio; + + // ---------- 7. 创建比例尺 ---------- + + // 计算条形的额外间距（如果启用） + const barPadding = variables.has_spacing ? 0.3 : 0.2; + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(sortedDimensions) + .range([0, innerHeight]) + .padding(barPadding); + + // X轴比例尺（用于堆叠条形图） + const xScale = d3.scaleLinear() + .domain([0, 100]) // 假设堆叠值总和为100% + .range([0, barChartWidth]); + + // 圆形面积比例尺（用于总值） + const maxCircleValue = d3.max(Object.values(dimensionCircleTotals)); + const minRadius = yScale.bandwidth() * 0.1; // 最小半径 + const maxRadius = Math.min(yScale.bandwidth() * 1.6,circleChartWidth*0.8) // 最大半径可以是两个条形的高度 + + // 替换圆形比例尺为正方形边长比例尺 + // 注意：在d3.scaleSqrt中，我们输入的值按平方根缩放，输出将是正方形的边长 + // 这样可以确保最终生成的正方形面积与数值大小成正比 + const squareSideScale = d3.scaleSqrt() // 使用平方根比例尺确保面积比例正确 + .domain([0, maxCircleValue]) + .range([minRadius, maxRadius]); + + // ---------- 8. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 9. 添加SVG定义 ---------- + + // 添加defs用于视觉效果 + const defs = svg.append("defs"); + + // 添加阴影滤镜（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 为每个组创建渐变（如果启用） + if (variables.has_gradient) { + groups.forEach(group => { + const barColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", `bar-gradient-${group.replace(/\s+/g, '-')}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(barColor, { mode: "darker", amount: 0.3 })); + }); + } + + // ---------- 10. 不添加标题 ---------- + + // ---------- 11. 创建主图表组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 12. 获取颜色的辅助函数 ---------- + + // 获取组的颜色 + const getColor = (group) => { + if (colorResolver.field(group, 0, { fallbackKey: "primary" }).value) { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + } + // 如果没有指定颜色，则使用主色或默认颜色 + return colorResolver.other("primary", { fallback: "#1E88E5" }).value; + }; + + // ---------- 13. 添加右侧圆圈图标题 ---------- + + if (totalFieldDescription) { + // 计算标题位置 - 右对齐 + const titleX = width - margin.right; + const titleY = margin.top - 20; // 标题在图表上方 + + svg.append("text") + .attr("x", titleX) + .attr("y", titleY) + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(totalFieldDescription); + } + chartUtils.legend.draw(svg, groups, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: margin.left, + y: margin.top - 30, + maxWidth: barChartWidth, + fitToWidth: true, + minFontSize: 8, + markerShape: "rect", + markerSize: 12, + labelGap: 5, + itemGap: 15, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + + + // ---------- 15. 为每个维度绘制堆叠条形和圆形 ---------- + + sortedDimensions.forEach((dimension, index) => { + const barHeight = yScale.bandwidth(); + const y = yScale(dimension); + const centerY = y + barHeight / 2; + + // 1. 添加维度标签 + g.append("text") + .attr("x", -labelMargin) // 放在left margin减去间距的位置 + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 2. 绘制堆叠条形 + const barSegments = []; // 存储条形段用于后续添加白线 + + groups.forEach((group, groupIndex) => { + if (!stackData[dimension][group]) return; + + const stackItem = stackData[dimension][group]; + const barWidth = xScale(stackItem.value); + const isLastGroup = groupIndex === groups.length - 1; + + // 只绘制有值的部分 + if (stackItem.value > 0) { + // 获取填充颜色（考虑渐变） + const fillColor = variables.has_gradient ? + `url(#bar-gradient-${group.replace(/\s+/g, '-')})` : + getColor(group); + + // 绘制条形 + const barSegment = g.append("rect") + .attr("x", xScale(stackItem.start)) + .attr("y", y) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", fillColor) + .attr("rx", variables.has_rounded_corners ? Math.min(barHeight * 0.2, 5) : 0) + .attr("ry", variables.has_rounded_corners ? Math.min(barHeight * 0.2, 5) : 0) + .style("stroke", variables.has_stroke ? colorResolver.variant(getColor(group), { mode: "darker", amount: 0.5 }) : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 存储条形段信息用于后续添加白线 + barSegments.push({ + x: xScale(stackItem.start), + end: xScale(stackItem.start) + barWidth, + y, + height: barHeight + }); + + // 测量标签宽度 + const formattedValue = `${chartUtils.format.autoText(stackItem.value)}${valueUnit}`; + const valueLabelFontSize = `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`; + const labelWidth = chartUtils.text.measure(tempSvg, formattedValue, { + fontFamily: typography.annotation.font_family, + fontSize: valueLabelFontSize, + fontWeight: typography.annotation.font_weight + }).width; + + // 判断标签是放在内部还是外部 + const minWidthForLabel = labelWidth + 5; // 确保有足够空间 + + if (barWidth > minWidthForLabel || !isLastGroup) { + // 如果条形宽度足够大或不是最后一组，添加内部标签（右对齐） + g.append("text") + .attr("x", xScale(stackItem.start) + barWidth - 5) // 距离右边缘5px + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "end") // 右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") // 白色文本更易读 + .text(formattedValue); + } else if (isLastGroup) { + // 如果是最后一组且条形宽度不够，添加外部标签 + g.append("text") + .attr("x", xScale(stackItem.start) + barWidth + 5) // 距离右边缘5px + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "start") // 左对齐（在条形外部） + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) // 使用文本颜色 + .text(formattedValue); + } + } + }); + + // 添加白线分隔相邻的条形段 + for (let i = 1; i < barSegments.length; i++) { + const x = barSegments[i].x; + g.append("line") + .attr("x1", x) + .attr("y1", y) + .attr("x2", x) + .attr("y2", y + barHeight) + .attr("stroke", "#FFFFFF") + .attr("stroke-width", 1); + } + + // 3. 绘制圆形（显示总值）改为正方形 + const circleValue = dimensionCircleTotals[dimension]; + if (circleValue > 0) { + const squareSide = squareSideScale(circleValue); // 获取正方形边长 + const squareX = barChartWidth + circleChartWidth / 2 - squareSide / 2; // 水平居中 + + // 绘制正方形 + g.append("rect") + .attr("x", squareX) + .attr("y", centerY - squareSide / 2) // 垂直居中 + .attr("width", squareSide) + .attr("height", squareSide) + .attr("fill", colorResolver.other("primary", { fallback: "#1E88E5" }).value) + .style("stroke", "#FFFFFF") + .style("stroke-width", 1.5) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 添加总值标签 + const formattedTotal = `${chartUtils.format.autoText(circleValue)}${totalUnit}`; + + // 测量文本宽度以决定放置位置 + const textWidth = chartUtils.text.measure(svg, formattedTotal, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + // 计算正方形中心坐标 + const squareCenterX = squareX + squareSide / 2; + + // 如果正方形足够大，将文本放在正方形内；否则放在上方 + if (squareSide > textWidth + 10) { + g.append("text") + .attr("x", squareCenterX) + .attr("y", centerY) + .attr("dy", "0.35em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", `${Math.min(20,Math.max(barHeight * 0.6, parseFloat(typography.annotation.font_size)))}px`) + .style("font-weight", typography.annotation.font_weight) + .style("fill", "#FFFFFF") + .text(formattedTotal); + } else { + g.append("text") + .attr("x", squareCenterX) + .attr("y", centerY - squareSide / 2 - 5) + .attr("dy", "0em") + .attr("text-anchor", "middle") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .style("font-weight", typography.annotation.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(formattedTotal); + } + } + }); + + // 最后清除临时SVG + tempSvg.remove(); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5.js new file mode 100644 index 0000000000000000000000000000000000000000..0717598f0f597b195621eaaca63729e90c171b58 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5.js @@ -0,0 +1,562 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_5", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[5, 30], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; // 图表总宽度 + const height = variables.height; // 图表总高度 + // 边距：top-顶部，right-右侧，bottom-底部，left-左侧 + const margin = { top: 80, right: 160, bottom: 60, left: 80 }; // 增加左侧边距用于图标 + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; // 绘图区宽度 + const innerHeight = height - margin.top - margin.bottom; // 绘图区高度 + + // ---------- 3. 提取字段名和单位 ---------- + + // 提取字段名称 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 获取所有字段的单位（如果存在且不是"none"） + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + const groupUnit = groupChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 过滤出要显示的组（排除Total Paid Leave，因为它通常是前两组的总和） + const displayGroups = groups.filter(g => g !== "Total Paid Leave"); + + // 计算每个维度的总值，用于排序 + const dimensionTotals = {}; + allDimensions.forEach(dimension => { + let total = 0; + displayGroups.forEach(group => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension && d[groupField] === group); + if (dataPoint) { + total += +dataPoint[valueField]; + } + }); + dimensionTotals[dimension] = total; + }); + + // 按总值降序排序维度 + const dimensions = [...allDimensions].sort((a, b) => { + // 先按总值排序 + const diff = dimensionTotals[b] - dimensionTotals[a]; + if (diff !== 0) return diff; + + // 如果总值相同，按字母顺序排序 + return String(a).localeCompare(String(b)); + }); + + // ---------- 5. 动态计算标签区域宽度 ---------- + + // 标志/图标尺寸 + const iconSize = 32; // 设置图标大小为32px + const iconPadding = 10; + + // 图例方块尺寸 + const legendSquareSize = 12; + const legendSpacing = 5; + + // 计算最大标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = iconSize + iconPadding + textWidth; + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算组标签宽度，用于图例 + let maxGroupWidth = 0; + displayGroups.forEach(group => { + const formattedGroup = groupUnit ? + `${group}${groupUnit}` : + `${group}`; + + const textWidth = chartUtils.text.measure(null, formattedGroup, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 调整左侧边距，确保有足够空间放置标签和图标 + margin.left = Math.max(margin.left, maxLabelWidth + 20); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色辅助函数 + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // 添加阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + displayGroups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + } + chartUtils.legend.draw(svg, displayGroups, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: margin.left, + y: margin.top - 20, + maxWidth: innerWidth + margin.right - 20, + fitToWidth: true, + minFontSize: 8, + markerShape: "rect", + markerSize: legendSquareSize, + labelGap: legendSpacing, + itemGap: legendSpacing, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + // ---------- 8. 创建主绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 创建比例尺和条形高度设置 ---------- + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 设置条形图的最大和最小高度 + const maxBarHeight = 24; // 最大高度24px + const minBarHeight = 16; // 最小高度16px + + // 计算适合的条形高度 - 根据数据量调整，但在min-max范围内 + const calculatedBarHeight = Math.min( + maxBarHeight, + Math.max(minBarHeight, innerHeight / dimensions.length / 2.5) + ); + + // 标签和条形之间的间距 + const barLabelGap = 5; // 增加到5px，与图中效果一致 + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(0.5); // 增加padding使条形间距更大 + + // 计算最大总值 + const maxTotal = d3.max(Object.values(dimensionTotals)); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, maxTotal * 1.05]) + .range([0, innerWidth]); + + // ---------- 10. 添加X轴（数值轴）---------- + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickSize(0) // 移除网格线 + .tickFormat(d => { + // 如果单位长度大于3，则不显示单位 + if (valueUnit && valueUnit.length > 3) { + return d; + } else { + return valueUnit ? `${d}${valueUnit}` : d; + } + }); + + // 添加X轴，但移除轴线 + const xAxisG = g.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(xAxis); + + // 移除所有轴线和刻度线 + xAxisG.select("path.domain").remove(); + xAxisG.selectAll(".tick line").remove(); + + // 仅保留文本 + xAxisG.selectAll("text") + .remove(); + // .style("font-family", typography.label.font_family) + // .style("font-size", typography.label.font_size) + // .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // ---------- 11. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension) - yScale.bandwidth()/2) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // ---------- 12. 绘制条形图和标签 ---------- + + // 估算标签宽度的函数 + const estimateLabelWidth = (text) => { + return chartUtils.text.measure(svg, text, { + fontFamily: typography.annotation.font_family, + fontSize: "14px", + fontWeight: typography.annotation.font_weight + }).width; + }; + + // 格式化函数 - 如果单位长度超过3，不显示单位 + const formatValueWithUnit = (value) => { + const formattedValue = chartUtils.format.autoText(value); + if (valueUnit && valueUnit.length > 3) { + return `${formattedValue}`; + } else { + return valueUnit ? `${formattedValue}${valueUnit}` : `${formattedValue}`; + } + }; + + // 标签内边距和偏移量 + const labelPadding = 4; + + // 绘制条形和标签 + dimensions.forEach((dimension, dimIndex) => { + // 获取当前行的Y位置（中心） + const rowCenterY = yScale(dimension); + + // 条形放在中心偏上 + const barY = rowCenterY - calculatedBarHeight - barLabelGap; + const barHeight = calculatedBarHeight; + + // 标签位置下移5px + const labelY = barY + barHeight + barLabelGap + labelPadding + 5; + + // 绘制图标和维度标签 + const iconX = -iconSize - iconPadding; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX) + .attr("y", rowCenterY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签 + g.append("text") + .attr("x", iconX - 5) + .attr("y", rowCenterY + 5) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 初始化X位置 + let xPos = 0; // 当前绘制位置 + + // 保存标签数据以便之后处理重叠 + const labelData = []; + + // 为每个组绘制条形和收集标签数据 + displayGroups.forEach(group => { + // 查找该维度和组的数据点 + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === group); + + if (dataPoint) { + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", xPos) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 收集标签数据 + const labelText = formatValueWithUnit(+dataPoint[valueField]); + const labelWidth = estimateLabelWidth(labelText); + + // 标签位置 - 默认放在条形图下方右对齐 + labelData.push({ + text: labelText, + x: xPos + barWidth, + y: labelY, + width: labelWidth, + color: getColor(group), + barEndX: xPos + barWidth, + barStartX: xPos, + barWidth: barWidth, + group: group + }); + + // 更新X位置 + xPos += barWidth; + } + }); + + // 处理标签重叠和位置调整 + if (labelData.length > 0) { + // 设置所有标签的初始文本锚点为右对齐 + labelData.forEach(label => { + label.textAnchor = "end"; + // 计算初始左边界 + label.leftEdge = label.x - label.width; + // 检查是否超出左边界 + label.outOfBounds = label.leftEdge < label.barStartX; + }); + + // 处理超出左边界的标签 + labelData.forEach(label => { + if (label.outOfBounds) { + // 如果条形宽度足够容纳文本+一些边距，则居中显示 + if (label.barWidth > label.width + 10) { + label.x = label.barStartX + label.barWidth / 2; + label.textAnchor = "middle"; + } else { + // 否则靠左侧显示 + label.x = label.barStartX + 5; // 略微缩进 + label.textAnchor = "start"; + } + } + }); + + // 更新所有标签的边界坐标 + labelData.forEach(label => { + if (label.textAnchor === "end") { + label.rightEdge = label.x; + label.leftEdge = label.x - label.width; + } else if (label.textAnchor === "middle") { + label.rightEdge = label.x + label.width / 2; + label.leftEdge = label.x - label.width / 2; + } else { // start + label.rightEdge = label.x + label.width; + label.leftEdge = label.x; + } + }); + + // 排序标签，从左到右 + labelData.sort((a, b) => a.barStartX - b.barStartX); + + // 处理标签重叠 + const minSpaceBetween = 15; // 标签之间的最小间距 + + // 从左到右检查和修复重叠 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + const nextLabel = labelData[i + 1]; + + // 检查当前标签与下一个标签是否重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 重叠处理策略： + // 1. 尝试将下一个标签向右移动 + nextLabel.textAnchor = "start"; + nextLabel.x = currentLabel.rightEdge + minSpaceBetween; + + // 更新边界 + nextLabel.rightEdge = nextLabel.x + nextLabel.width; + nextLabel.leftEdge = nextLabel.x; + + } + } + + // 最后一轮检查 - 处理可能因前面调整产生的新重叠 + // 这种情况可能发生在有3个以上标签且空间紧张时 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + let nextLabel = labelData[i + 1]; + + // 如果已经垂直错开，则跳过 + if (nextLabel.offsetVertical) continue; + + // 再次检查重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 如果仍然重叠，使用垂直错开 + nextLabel.y += barHeight + 5; + nextLabel.offsetVertical = true; + } + } + } + + // 为每个标签绘制半透明背景条形 + labelData.forEach(label => { + // 绘制灰色半透明背景条形 + g.append("rect") + .attr("x", label.barStartX) + .attr("y", label.y - barHeight/2) // 垂直居中于标签 + .attr("width", label.barWidth) + .attr("height", barHeight) + .attr("fill", "white") + .attr("opacity", 0.5) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0); + }); + + // 绘制所有标签 + labelData.forEach(label => { + g.append("text") + .attr("x", label.x) + .attr("y", label.y) + .attr("text-anchor", label.textAnchor || "end") // 默认右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", "14px") // 增大字体 + .style("font-weight", typography.annotation.font_weight) + .style("fill", label.color) + .text(label.text); + }); + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5_hand.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5_hand.js new file mode 100644 index 0000000000000000000000000000000000000000..f5bef17bab00dc2fedd9786f19e31b7b9654993d --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_5_hand.js @@ -0,0 +1,583 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_5_hand", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; // 图表总宽度 + const height = variables.height; // 图表总高度 + // 边距：top-顶部，right-右侧，bottom-底部，left-左侧 + const margin = { top: 80, right: 160, bottom: 60, left: 80 }; // 增加左侧边距用于图标 + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; // 绘图区宽度 + const innerHeight = height - margin.top - margin.bottom; // 绘图区高度 + + // ---------- 3. 提取字段名和单位 ---------- + + // 提取字段名称 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 获取所有字段的单位（如果存在且不是"none"） + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + const groupUnit = groupChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 过滤出要显示的组（排除Total Paid Leave，因为它通常是前两组的总和） + const displayGroups = groups.filter(g => g !== "Total Paid Leave"); + + // 计算每个维度的总值，用于排序 + const dimensionTotals = {}; + allDimensions.forEach(dimension => { + let total = 0; + displayGroups.forEach(group => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension && d[groupField] === group); + if (dataPoint) { + total += +dataPoint[valueField]; + } + }); + dimensionTotals[dimension] = total; + }); + + // 按总值降序排序维度 + const dimensions = [...allDimensions].sort((a, b) => { + // 先按总值排序 + const diff = dimensionTotals[b] - dimensionTotals[a]; + if (diff !== 0) return diff; + + // 如果总值相同，按字母顺序排序 + return String(a).localeCompare(String(b)); + }); + + // ---------- 5. 动态计算标签区域宽度 ---------- + + // 标志/图标尺寸 + const iconSize = 32; // 设置图标大小为32px + const iconPadding = 10; + + // 图例方块尺寸 + const legendSquareSize = 12; + const legendSpacing = 5; + + // 计算最大标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = iconSize + iconPadding + textWidth; + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算组标签宽度，用于图例 + let maxGroupWidth = 0; + displayGroups.forEach(group => { + const formattedGroup = groupUnit ? + `${group}${groupUnit}` : + `${group}`; + + const textWidth = chartUtils.text.measure(null, formattedGroup, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 调整左侧边距，确保有足够空间放置标签和图标 + margin.left = Math.max(margin.left, maxLabelWidth + 20); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色辅助函数 + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // 添加阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + displayGroups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + } + chartUtils.legend.draw(svg, displayGroups, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: margin.left, + y: margin.top - 20, + maxWidth: innerWidth + margin.right - 20, + fitToWidth: true, + minFontSize: 8, + markerShape: "rect", + markerSize: legendSquareSize, + labelGap: legendSpacing, + itemGap: legendSpacing, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + // ---------- 8. 创建主绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 创建比例尺和条形高度设置 ---------- + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 设置条形图的最大和最小高度 + const maxBarHeight = 24; // 最大高度24px + const minBarHeight = 16; // 最小高度16px + + // 计算适合的条形高度 - 根据数据量调整，但在min-max范围内 + const calculatedBarHeight = Math.min( + maxBarHeight, + Math.max(minBarHeight, innerHeight / dimensions.length / 2.5) + ); + + // 标签和条形之间的间距 + const barLabelGap = 5; // 增加到5px，与图中效果一致 + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(0.5); // 增加padding使条形间距更大 + + // 计算最大总值 + const maxTotal = d3.max(Object.values(dimensionTotals)); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, maxTotal * 1.05]) + .range([0, innerWidth]); + + // ---------- 10. 添加X轴（数值轴）---------- + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickSize(0) // 移除网格线 + .tickFormat(d => { + // 如果单位长度大于3，则不显示单位 + if (valueUnit && valueUnit.length > 3) { + return d; + } else { + return valueUnit ? `${d}${valueUnit}` : d; + } + }); + + // 添加X轴，但移除轴线 + const xAxisG = g.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(xAxis); + + // 移除所有轴线和刻度线 + xAxisG.select("path.domain").remove(); + xAxisG.selectAll(".tick line").remove(); + + // 仅保留文本 + xAxisG.selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // ---------- 11. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension) - yScale.bandwidth()/2) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // ---------- 12. 绘制条形图和标签 ---------- + + // 估算标签宽度的函数 + const estimateLabelWidth = (text) => { + return chartUtils.text.measure(svg, text, { + fontFamily: typography.annotation.font_family, + fontSize: "14px", + fontWeight: typography.annotation.font_weight + }).width; + }; + + // 格式化函数 - 如果单位长度超过3，不显示单位 + const formatValueWithUnit = (value) => { + const formattedValue = chartUtils.format.autoText(value); + if (valueUnit && valueUnit.length > 3) { + return `${formattedValue}`; + } else { + return valueUnit ? `${formattedValue}${valueUnit}` : `${formattedValue}`; + } + }; + + // 标签内边距和偏移量 + const labelPadding = 4; + + // 绘制条形和标签 + dimensions.forEach((dimension, dimIndex) => { + // 获取当前行的Y位置（中心） + const rowCenterY = yScale(dimension); + + // 条形放在中心偏上 + const barY = rowCenterY - calculatedBarHeight - barLabelGap; + const barHeight = calculatedBarHeight; + + // 标签位置下移5px + const labelY = barY + barHeight + barLabelGap + labelPadding + 5; + + // 绘制图标和维度标签 + const iconX = -iconSize - iconPadding; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX) + .attr("y", rowCenterY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签 + g.append("text") + .attr("x", iconX - 5) + .attr("y", rowCenterY + 5) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 初始化X位置 + let xPos = 0; // 当前绘制位置 + + // 保存标签数据以便之后处理重叠 + const labelData = []; + + // 为每个组绘制条形和收集标签数据 + displayGroups.forEach(group => { + // 查找该维度和组的数据点 + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === group); + + if (dataPoint) { + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", xPos) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 收集标签数据 + const labelText = formatValueWithUnit(+dataPoint[valueField]); + const labelWidth = estimateLabelWidth(labelText); + + // 标签位置 - 默认放在条形图下方右对齐 + labelData.push({ + text: labelText, + x: xPos + barWidth, + y: labelY, + width: labelWidth, + color: getColor(group), + barEndX: xPos + barWidth, + barStartX: xPos, + barWidth: barWidth, + group: group + }); + + // 更新X位置 + xPos += barWidth; + } + }); + + // 处理标签重叠和位置调整 + if (labelData.length > 0) { + // 设置所有标签的初始文本锚点为右对齐 + labelData.forEach(label => { + label.textAnchor = "end"; + // 计算初始左边界 + label.leftEdge = label.x - label.width; + // 检查是否超出左边界 + label.outOfBounds = label.leftEdge < label.barStartX; + }); + + // 处理超出左边界的标签 + labelData.forEach(label => { + if (label.outOfBounds) { + // 如果条形宽度足够容纳文本+一些边距，则居中显示 + if (label.barWidth > label.width + 10) { + label.x = label.barStartX + label.barWidth / 2; + label.textAnchor = "middle"; + } else { + // 否则靠左侧显示 + label.x = label.barStartX + 5; // 略微缩进 + label.textAnchor = "start"; + } + } + }); + + // 更新所有标签的边界坐标 + labelData.forEach(label => { + if (label.textAnchor === "end") { + label.rightEdge = label.x; + label.leftEdge = label.x - label.width; + } else if (label.textAnchor === "middle") { + label.rightEdge = label.x + label.width / 2; + label.leftEdge = label.x - label.width / 2; + } else { // start + label.rightEdge = label.x + label.width; + label.leftEdge = label.x; + } + }); + + // 排序标签，从左到右 + labelData.sort((a, b) => a.barStartX - b.barStartX); + + // 处理标签重叠 + const minSpaceBetween = 15; // 标签之间的最小间距 + + // 从左到右检查和修复重叠 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + const nextLabel = labelData[i + 1]; + + // 检查当前标签与下一个标签是否重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 重叠处理策略： + // 1. 尝试将下一个标签向右移动 + nextLabel.textAnchor = "start"; + nextLabel.x = currentLabel.rightEdge + minSpaceBetween; + + // 更新边界 + nextLabel.rightEdge = nextLabel.x + nextLabel.width; + nextLabel.leftEdge = nextLabel.x; + + } + } + + // 最后一轮检查 - 处理可能因前面调整产生的新重叠 + // 这种情况可能发生在有3个以上标签且空间紧张时 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + let nextLabel = labelData[i + 1]; + + // 如果已经垂直错开，则跳过 + if (nextLabel.offsetVertical) continue; + + // 再次检查重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 如果仍然重叠，使用垂直错开 + nextLabel.y += barHeight + 5; + nextLabel.offsetVertical = true; + } + } + } + + // 为每个标签绘制半透明背景条形 + labelData.forEach(label => { + // 绘制灰色半透明背景条形 + g.append("rect") + .attr("x", label.barStartX) + .attr("y", label.y - barHeight/2) // 垂直居中于标签 + .attr("width", label.barWidth) + .attr("height", barHeight) + .attr("fill", "white") + .attr("opacity", 0.5) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0); + }); + + // 绘制所有标签 + labelData.forEach(label => { + g.append("text") + .attr("x", label.x) + .attr("y", label.y) + .attr("text-anchor", label.textAnchor || "end") // 默认右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", "14px") // 增大字体 + .style("font-weight", typography.annotation.font_weight) + .style("fill", label.color) + .text(label.text); + }); + }); + + const roughness = 1; + const bowing = 1; + const fillStyle = "solid"; + const randomize = false; + const pencilFilter = false; + + const svgConverter = new svg2roughjs.Svg2Roughjs(containerSelector); + svgConverter.pencilFilter = pencilFilter; + svgConverter.randomize = randomize; + svgConverter.svg = svg.node(); + svgConverter.roughConfig = { + bowing, + roughness, + fillStyle + }; + svgConverter.sketch(); + // Remove the first SVG element if it exists + const firstSvg = document.querySelector(`${containerSelector} svg`); + if (firstSvg) { + firstSvg.remove(); + } + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_6.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_6.js new file mode 100644 index 0000000000000000000000000000000000000000..4f0aeedc44ee4ab99084a24e3e220a23ca973742 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_6.js @@ -0,0 +1,561 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_6", + "chart_for": "comparison", + "is_composite": false, + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2, 30], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": [], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "dark", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "yes", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 水平堆叠条形图实现 - 使用D3.js +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置，如果不存在则使用空对象 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors_dark || { text_color: "#333333" }; // 颜色设置，如果不存在则使用默认值 + const colorResolver = chartUtils.color.resolver(jsonData); + const images = jsonData.images || { field: {}, other: {} }; // 图像(国旗等) + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 检查并设置缺失的视觉效果变量，确保不会因为缺少变量而出错 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 - 在添加新图表前移除可能存在的内容 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸和边距 + const width = variables.width; // 图表总宽度 + const height = variables.height; // 图表总高度 + // 边距：top-顶部，right-右侧，bottom-底部，left-左侧 + const margin = { top: 80, right: 160, bottom: 60, left: 80 }; // 增加左侧边距用于图标 + + // 计算实际绘图区域尺寸 + const innerWidth = width - margin.left - margin.right; // 绘图区宽度 + const innerHeight = height - margin.top - margin.bottom; // 绘图区高度 + + // ---------- 3. 提取字段名和单位 ---------- + + // 提取字段名称 + const dimensionChannel = chartUtils.schema.column(dataColumns, 0, { fallbackKey: "dimension" }); + const valueChannel = chartUtils.schema.column(dataColumns, 1, { fallbackKey: "value" }); + const groupChannel = chartUtils.schema.column(dataColumns, 2, { fallbackKey: "group" }); + const dimensionField = dimensionChannel.key; + const valueField = valueChannel.key; + const groupField = groupChannel.key; + + // 获取所有字段的单位（如果存在且不是"none"） + const dimensionUnit = dimensionChannel.unit; + const valueUnit = valueChannel.unit; + const groupUnit = groupChannel.unit; + + // ---------- 4. 数据处理 ---------- + + // 获取唯一维度值和分组值 + const allDimensions = [...new Set(chartData.map(d => d[dimensionField]))]; + const groups = [...new Set(chartData.map(d => d[groupField]))]; + + // 过滤出要显示的组（排除Total Paid Leave，因为它通常是前两组的总和） + const displayGroups = groups.filter(g => g !== "Total Paid Leave"); + + // 计算每个维度的总值，用于排序 + const dimensionTotals = {}; + allDimensions.forEach(dimension => { + let total = 0; + displayGroups.forEach(group => { + const dataPoint = chartData.find(d => d[dimensionField] === dimension && d[groupField] === group); + if (dataPoint) { + total += +dataPoint[valueField]; + } + }); + dimensionTotals[dimension] = total; + }); + + // 按总值降序排序维度 + const dimensions = [...allDimensions].sort((a, b) => { + // 先按总值排序 + const diff = dimensionTotals[b] - dimensionTotals[a]; + if (diff !== 0) return diff; + + // 如果总值相同，按字母顺序排序 + return String(a).localeCompare(String(b)); + }); + + // ---------- 5. 动态计算标签区域宽度 ---------- + + // 标志/图标尺寸 + const iconSize = 32; // 设置图标大小为32px + const iconPadding = 10; + + // 图例方块尺寸 + const legendSquareSize = 12; + const legendSpacing = 5; + + // 计算最大标签宽度 + let maxLabelWidth = 0; + dimensions.forEach(dimension => { + // 格式化维度名称（附加单位，如果有） + const formattedDimension = dimensionUnit ? + `${dimension}${dimensionUnit}` : + `${dimension}`; + + const textWidth = chartUtils.text.measure(null, formattedDimension, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + const totalWidth = iconSize + iconPadding + textWidth; + + maxLabelWidth = Math.max(maxLabelWidth, totalWidth); + }); + + // 计算组标签宽度，用于图例 + let maxGroupWidth = 0; + displayGroups.forEach(group => { + const formattedGroup = groupUnit ? + `${group}${groupUnit}` : + `${group}`; + + const textWidth = chartUtils.text.measure(null, formattedGroup, { + fontFamily: typography.label.font_family, + fontSize: typography.label.font_size, + fontWeight: typography.label.font_weight + }).width; + + maxGroupWidth = Math.max(maxGroupWidth, textWidth); + }); + + // 调整左侧边距，确保有足够空间放置标签和图标 + margin.left = Math.max(margin.left, maxLabelWidth + 20); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 6.1 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色辅助函数 + const getColor = (group) => { + return colorResolver.field(group, 0, { fallbackKey: "primary" }).value; + }; + + // 添加阴影效果（如果启用） + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 添加渐变效果（如果启用） + if (variables.has_gradient) { + displayGroups.forEach(group => { + const gradientId = `gradient-${group.replace(/\s+/g, '-').toLowerCase()}`; + const baseColor = getColor(group); + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", colorResolver.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + } + chartUtils.legend.draw(svg, displayGroups, { + color: group => getColor(group), + colorResolver, + colors, + }, { + x: margin.left, + y: margin.top - 20, + maxWidth: innerWidth + margin.right - 20, + fitToWidth: true, + minFontSize: 8, + markerShape: "rect", + markerSize: legendSquareSize, + labelGap: legendSpacing, + itemGap: legendSpacing, + fontSize: typography.label.font_size, + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + textColor: colorResolver.text({ fallback: "#333333" }).value, + }); + // ---------- 8. 创建主绘图组 ---------- + + const g = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 9. 创建比例尺和条形高度设置 ---------- + + // 获取描边颜色 + const getStrokeColor = () => { + const stroke = colorResolver.other("stroke_color", { fallback: "" }).value; + if (stroke) return stroke; + return colorResolver.available(0, { fallback: "#333333" }).value; + }; + const strokeColor = getStrokeColor(); + + // 设置条形图的最大和最小高度 + const maxBarHeight = 24; // 最大高度24px + const minBarHeight = 16; // 最小高度16px + + // 计算适合的条形高度 - 根据数据量调整，但在min-max范围内 + const calculatedBarHeight = Math.min( + maxBarHeight, + Math.max(minBarHeight, innerHeight / dimensions.length / 2.5) + ); + + // 标签和条形之间的间距 + const barLabelGap = 5; // 增加到5px，与图中效果一致 + + // Y轴比例尺（用于维度） + const yScale = d3.scaleBand() + .domain(dimensions) + .range([0, innerHeight]) + .padding(0.5); // 增加padding使条形间距更大 + + // 计算最大总值 + const maxTotal = d3.max(Object.values(dimensionTotals)); + + // X轴比例尺（用于数值） + const xScale = d3.scaleLinear() + .domain([0, maxTotal * 1.05]) + .range([0, innerWidth]); + + // ---------- 10. 添加X轴（数值轴）---------- + const xAxis = d3.axisBottom(xScale) + .ticks(5) + .tickSize(0) // 移除网格线 + .tickFormat(d => { + // 如果单位长度大于3，则不显示单位 + if (valueUnit && valueUnit.length > 3) { + return d; + } else { + return valueUnit ? `${d}${valueUnit}` : d; + } + }); + + // 添加X轴，但移除轴线 + const xAxisG = g.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${innerHeight})`) + .call(xAxis); + + // 移除所有轴线和刻度线 + xAxisG.select("path.domain").remove(); + xAxisG.selectAll(".tick line").remove(); + + // 仅保留文本 + xAxisG.selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // ---------- 11. 添加交替行背景 ---------- + if (jsonData.variation?.background === "styled") { + dimensions.forEach((dimension, i) => { + if (i % 2 === 0) { + g.append("rect") + .attr("x", -margin.left/2) + .attr("y", yScale(dimension) - yScale.bandwidth()/2) + .attr("width", innerWidth + margin.left/2 + margin.right/2) + .attr("height", yScale.bandwidth()) + .attr("class","background") + .attr("fill", colorResolver.background({ fallback: "#f5f5f5" }).value) + .attr("opacity", 0.8); + } + }); + } + + // ---------- 12. 绘制条形图和标签 ---------- + + // 估算标签宽度的函数 + const estimateLabelWidth = (text) => { + return chartUtils.text.measure(svg, text, { + fontFamily: typography.annotation.font_family, + fontSize: "14px", + fontWeight: typography.annotation.font_weight + }).width; + }; + + // 格式化函数 - 如果单位长度超过3，不显示单位 + const formatValueWithUnit = (value) => { + const formattedValue = chartUtils.format.autoText(value); + if (valueUnit && valueUnit.length > 3) { + return `${formattedValue}`; + } else { + return valueUnit ? `${formattedValue}${valueUnit}` : `${formattedValue}`; + } + }; + + // 标签内边距和偏移量 + const labelPadding = 4; + + // 绘制条形和标签 + dimensions.forEach((dimension, dimIndex) => { + // 获取当前行的Y位置（中心） + const rowCenterY = yScale(dimension); + + // 条形放在中心偏上 + const barY = rowCenterY - calculatedBarHeight - barLabelGap; + const barHeight = calculatedBarHeight; + + // 标签位置下移5px + const labelY = barY + barHeight + barLabelGap + labelPadding + 5; + + // 绘制图标和维度标签 + const iconX = -iconSize - iconPadding; + + // 添加图标（如果有） + if (images.field && images.field[dimension]) { + g.append("image") + .attr("x", iconX) + .attr("y", rowCenterY - iconSize / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("xlink:href", images.field[dimension]); + } + + // 添加维度标签 + g.append("text") + .attr("x", iconX - 5) + .attr("y", rowCenterY + 5) + .attr("dy", "0.35em") + .attr("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("font-weight", typography.label.font_weight) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(dimension); + + // 初始化X位置 + let xPos = 0; // 当前绘制位置 + + // 保存标签数据以便之后处理重叠 + const labelData = []; + + // 为每个组绘制条形和收集标签数据 + displayGroups.forEach(group => { + // 查找该维度和组的数据点 + const dataPoint = chartData.find(d => + d[dimensionField] === dimension && d[groupField] === group); + + if (dataPoint) { + const barWidth = xScale(+dataPoint[valueField]); + + // 绘制条形 + g.append("rect") + .attr("x", xPos) + .attr("y", barY) + .attr("width", barWidth) + .attr("height", barHeight) + .attr("fill", variables.has_gradient ? + `url(#gradient-${group.replace(/\s+/g, '-').toLowerCase()})` : + getColor(group)) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0) + .style("stroke", variables.has_stroke ? strokeColor : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + // 收集标签数据 + const labelText = formatValueWithUnit(+dataPoint[valueField]); + const labelWidth = estimateLabelWidth(labelText); + + // 标签位置 - 默认放在条形图下方右对齐 + labelData.push({ + text: labelText, + x: xPos + barWidth, + y: labelY, + width: labelWidth, + color: getColor(group), + barEndX: xPos + barWidth, + barStartX: xPos, + barWidth: barWidth, + group: group + }); + + // 更新X位置 + xPos += barWidth; + } + }); + + // 处理标签重叠和位置调整 + if (labelData.length > 0) { + // 设置所有标签的初始文本锚点为右对齐 + labelData.forEach(label => { + label.textAnchor = "end"; + // 计算初始左边界 + label.leftEdge = label.x - label.width; + // 检查是否超出左边界 + label.outOfBounds = label.leftEdge < label.barStartX; + }); + + // 处理超出左边界的标签 + labelData.forEach(label => { + if (label.outOfBounds) { + // 如果条形宽度足够容纳文本+一些边距，则居中显示 + if (label.barWidth > label.width + 10) { + label.x = label.barStartX + label.barWidth / 2; + label.textAnchor = "middle"; + } else { + // 否则靠左侧显示 + label.x = label.barStartX + 5; // 略微缩进 + label.textAnchor = "start"; + } + } + }); + + // 更新所有标签的边界坐标 + labelData.forEach(label => { + if (label.textAnchor === "end") { + label.rightEdge = label.x; + label.leftEdge = label.x - label.width; + } else if (label.textAnchor === "middle") { + label.rightEdge = label.x + label.width / 2; + label.leftEdge = label.x - label.width / 2; + } else { // start + label.rightEdge = label.x + label.width; + label.leftEdge = label.x; + } + }); + + // 排序标签，从左到右 + labelData.sort((a, b) => a.barStartX - b.barStartX); + + // 处理标签重叠 + const minSpaceBetween = 15; // 标签之间的最小间距 + + // 从左到右检查和修复重叠 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + const nextLabel = labelData[i + 1]; + + // 检查当前标签与下一个标签是否重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 重叠处理策略： + // 1. 尝试将下一个标签向右移动 + nextLabel.textAnchor = "start"; + nextLabel.x = currentLabel.rightEdge + minSpaceBetween; + + // 更新边界 + nextLabel.rightEdge = nextLabel.x + nextLabel.width; + nextLabel.leftEdge = nextLabel.x; + + } + } + + // 最后一轮检查 - 处理可能因前面调整产生的新重叠 + // 这种情况可能发生在有3个以上标签且空间紧张时 + for (let i = 0; i < labelData.length - 1; i++) { + const currentLabel = labelData[i]; + let nextLabel = labelData[i + 1]; + + // 如果已经垂直错开，则跳过 + if (nextLabel.offsetVertical) continue; + + // 再次检查重叠 + if (currentLabel.rightEdge + minSpaceBetween > nextLabel.leftEdge) { + // 如果仍然重叠，使用垂直错开 + nextLabel.y += barHeight + 5; + nextLabel.offsetVertical = true; + } + } + } + + // 为每个标签绘制半透明背景条形 + labelData.forEach(label => { + // 绘制灰色半透明背景条形 + g.append("rect") + .attr("x", label.barStartX) + .attr("y", label.y - barHeight/2) // 垂直居中于标签 + .attr("width", label.barWidth) + .attr("height", barHeight) + .attr("fill", "#777777") + .attr("opacity", 0.5) + .attr("rx", variables.has_rounded_corners ? 3 : 0) + .attr("ry", variables.has_rounded_corners ? 3 : 0); + }); + + // 绘制所有标签 + labelData.forEach(label => { + g.append("text") + .attr("x", label.x) + .attr("y", label.y) + .attr("text-anchor", label.textAnchor || "end") // 默认右对齐 + .style("font-family", typography.annotation.font_family) + .style("font-size", "14px") // 增大字体 + .style("font-weight", typography.annotation.font_weight) + .style("fill", label.color) + .text(label.text); + }); + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_7.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_7.js new file mode 100644 index 0000000000000000000000000000000000000000..a3ccba2cff36ff74ccead51c2efb908b27df2257 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_7.js @@ -0,0 +1,328 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_7", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 100, // 增加右侧边距，为图标预留空间 + bottom: 80, + left: 200 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, chartWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 用于测量文本宽度的辅助函数 + function measureTextWidth(text, fontSize) { + return chartUtils.text.measure(null, text, { fontSize: parseFloat(fontSize) || fontSize }).width; + } + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const formattedText = `${chartUtils.format.autoText(value)}${yUnit}`; + const textwidth = measureTextWidth(formattedText, typography.annotation.font_size); + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formattedText : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()); + + // 添加黑色背景矩形和白色文本 + yAxis.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + + // 获取标签文本内容 + const labelText = d; + + // 移除原始文本 + tick.select("text").remove(); + + // 添加黑色背景矩形 + tick.append("rect") + .attr("x", -margin.left + 5) // 稍微缩进一点 + .attr("y", -yScale.bandwidth() / 2) + .attr("width", margin.left - 10) // 减去一些边距 + .attr("height", yScale.bandwidth()) + .attr("fill", "black") + .attr("opacity", 0.5) + .attr("rx", 3) + .attr("ry", 3); + + // 添加白色文本 + tick.append("text") + .attr("x", -10) // 保持一些右侧边距 + .attr("y", 0) + .attr("text-anchor", "end") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.label.font_family) + .style("font-size", 12) + .text(labelText); + }); + + let bandWidth = yScale.bandwidth(); + let iconSize = yScale.bandwidth() * 0.7; + + // 在右侧添加图标 + if (jsonData.images) { + chartGroup.selectAll(".icon") + .data(processedData) + .enter() + .append("image") + .attr("class", "icon") + .attr("x", chartWidth + 10) // 放在条形图右侧 + .attr("y", d => yScale(d.period) + (yScale.bandwidth() - iconSize) / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", d => jsonData.images.field[d.period]); + } + + // ---------- 8. 图例 ---------- + + // 测量所有图例项目的文本宽度 + const getLegendItemWidth = (text, fontSize) => { + return measureTextWidth(text, fontSize) + 30; // 增加到30px，为色块和文本间留出更多空间 + }; + + const legendFontSize = "14px"; + let legendItems = []; + + // 计算标题宽度 + const titleWidth = measureTextWidth(groupField, legendFontSize) + 25; // 增加到25px，为标题和第一个图例项留出更多空间 + + // 计算每个图例项的宽度 + groups.forEach(group => { + legendItems.push({ + key: group, + width: getLegendItemWidth(group, legendFontSize) + }); + }); + + // 计算总宽度 + const totalLegendWidth = titleWidth + legendItems.reduce((sum, item) => sum + item.width, 0); + + // 创建图例布局 + // 检查是否需要单行或双行布局 + const availableWidth = width - 20; // 留出一些边距 + const legendItemKeys = legendItems.map(item => item.key); + const legendColorOpts = { colorScale, colorResolver, colors }; + const legendStyleBase = { + markerShape: "rect", + markerSize: 15, + labelGap: 5, + itemGap: 10, + fontSize: legendFontSize, + textColor: "#333", + }; + if (totalLegendWidth < availableWidth) { + const titleG = svg.append("g").attr("transform", "translate(0, 30)"); + titleG.append("text") + .attr("x", 0).attr("y", 0).attr("dominant-baseline", "middle") + .attr("fill", "#333").style("font-size", legendFontSize).style("font-weight", "bold") + .text(groupField); + chartUtils.legend.draw(svg, legendItemKeys, legendColorOpts, { ...legendStyleBase, x: titleWidth, y: 30 }); + } else { + const titleG = svg.append("g").attr("transform", "translate(0, 30)"); + titleG.append("text") + .attr("x", 0).attr("y", 0).attr("dominant-baseline", "middle") + .attr("fill", "#333").style("font-size", legendFontSize).style("font-weight", "bold") + .text(groupField); + chartUtils.legend.draw(svg, legendItemKeys, legendColorOpts, { ...legendStyleBase, x: 0, y: 55 }); + margin.top = 75; + chartGroup.attr("transform", `translate(${margin.left}, ${margin.top})`); + } + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_8.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_8.js new file mode 100644 index 0000000000000000000000000000000000000000..8ef14d33aa1879eb11440baa96718c69ce21202c --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_8.js @@ -0,0 +1,311 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_8", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 8], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 100, // 增加右侧边距，为图标预留空间 + bottom: 80, + left: 50 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.4); // 增加内边距，增加条形图之间的间距 + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total) * 1.1]) // 增加10%空间 + .range([0, chartWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 用于测量文本宽度的辅助函数 + function measureTextWidth(text, fontSize) { + return chartUtils.text.measure(null, text, { fontSize: parseFloat(fontSize) || fontSize }).width; + } + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0); + + // 添加组标签（在条形图上半部分） + layers.selectAll(".group-label") + .data(d => d) + .enter().append("text") + .attr("class", "group-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.35) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text((d, i, nodes) => { + // 获取当前rect所属的layer组，从而获取group名称 + const parentGroup = d3.select(nodes[i].parentNode); + const groupData = parentGroup.datum(); + + // 检查宽度，如果太小则不显示 + const width = xScale(d[1]) - xScale(d[0]); + if (width < 5) return ""; // 当宽度太小时不显示标签 + + return groupData.key; // 使用堆叠数据的key作为group label + }); + + // 添加数值标注（在条形图下半部分） + layers.selectAll(".value-label") + .data(d => d) + .enter().append("text") + .attr("class", "value-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.7) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + const value = d[1] - d[0]; + // 只有在有值的情况下才显示 + if (value <= 0) return "0"; // 不显示 + + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + + // 检查宽度，如果太小或值为0则不显示 + if (width < 5 || value <= 0) return ""; + + // 只在值大于0时显示 + return chartUtils.format.autoText(value) + (yUnit ? yUnit : ''); + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()); + + // 添加X标签到条形图上方 + processedData.forEach(d => { + chartGroup.append("text") + .attr("x", 0) // 与条形图左端对齐 + .attr("y", yScale(d.period) - 10) // 放在条形图上方10px + .style("text-anchor", "start") + .style("fill", "#000000") // 黑色字体 + .style("font-size", "15px") // 15px字体大小 + .style("font-family", typography.label.font_family) + .text(d.period); + }); + + // 移除原始Y轴标签和背景 + yAxis.selectAll(".tick text").remove(); + + let bandWidth = yScale.bandwidth(); + let iconSize = yScale.bandwidth() * 0.7; + + // 在右侧添加图标 + if (jsonData.images) { + chartGroup.selectAll(".icon") + .data(processedData) + .enter() + .append("image") + .attr("class", "icon") + .attr("x", chartWidth + 10) // 放在条形图右侧 + .attr("y", d => yScale(d.period) + (yScale.bandwidth() - iconSize) / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", d => jsonData.images.field[d.period]); + } + + // 移除图例部分 + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_9.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_9.js new file mode 100644 index 0000000000000000000000000000000000000000..3fb6d29de5a4992a5a8d3e5d20a02ffda7706e7a --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_bar_chart_9.js @@ -0,0 +1,365 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Bar Chart", + "chart_name": "horizontal_stacked_bar_chart_9", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 8], [0, "inf"], [2, 4]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors_dark || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 100, // 增加右侧边距，为图标预留空间 + bottom: 80, + left: 50 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.4); // 增加内边距，增加条形图之间的间距 + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total) * 1.1]) // 增加10%空间 + .range([0, chartWidth]) + .nice(); + + const colorScale = colorResolver.scale(groups, { palette: "category10" }) + + // 用于测量文本宽度的辅助函数 + function measureTextWidth(text, fontSize) { + return chartUtils.text.measure(null, text, { fontSize: parseFloat(fontSize) || fontSize }).width; + } + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 创建渐变定义 + const defs = svg.append("defs"); + + // 为每个组创建一个渐变 + groups.forEach((group, i) => { + const gradient = defs.append("linearGradient") + .attr("id", `metalGradient-${i}`) + .attr("x1", "0%") + .attr("y1", "0%") + .attr("x2", "100%") + .attr("y2", "0%"); + + // 添加渐变停止点 + const baseColor = colorScale(group); + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "brighter", amount: 0.5 })); + + gradient.append("stop") + .attr("offset", "50%") + .attr("stop-color", baseColor); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", chartUtils.color.variant(baseColor, { mode: "darker", amount: 0.3 })); + }); + + // 创建阴影过滤器 + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("height", "130%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3) + .attr("result", "blur"); + + filter.append("feOffset") + .attr("in", "blur") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetBlur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode") + .attr("in", "offsetBlur"); + feMerge.append("feMergeNode") + .attr("in", "SourceGraphic"); + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d, i) => `url(#metalGradient-${i})`); + + layers.selectAll("rect") + .data(d => d) + .enter().append("rect") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .style("stroke", variables.has_stroke ? "#ffffff" : "none") + .style("stroke-width", variables.has_stroke ? 1 : 0) + .style("filter", "url(#shadow)"); + + // 添加组标签（在条形图上半部分） + layers.selectAll(".group-label") + .data(d => d) + .enter().append("text") + .attr("class", "group-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.35) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#000000") // 改为黑色以增强可读性 + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text((d, i, nodes) => { + // 获取当前rect所属的layer组，从而获取group名称 + const parentGroup = d3.select(nodes[i].parentNode); + const groupData = parentGroup.datum(); + + // 检查宽度，如果太小则不显示 + const width = xScale(d[1]) - xScale(d[0]); + if (width < 5) return ""; // 当宽度太小时不显示标签 + + return groupData.key; // 使用堆叠数据的key作为group label + }); + + // 添加数值标注（在条形图下半部分） + layers.selectAll(".value-label") + .data(d => d) + .enter().append("text") + .attr("class", "value-label") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() * 0.7) + .attr("x", d => { + // 始终在条形图内显示 + return xScale(d[0]) + 5; // 左对齐，留出5px边距 + }) + .attr("text-anchor", "start") + .attr("dominant-baseline", "middle") + .style("fill", "#000000") // 改为黑色以增强可读性 + .style("font-family", typography.annotation.font_family) + .style("font-size", d => { + const width = xScale(d[1]) - xScale(d[0]); + const value = d[1] - d[0]; + // 只有在有值的情况下才显示 + if (value <= 0) return "0"; // 不显示 + + // 根据宽度动态调整字体大小 + if (width < 40) { + return "8px"; // 最小字体 + } else if (width < 60) { + return "10px"; // 中等字体 + } else { + return typography.annotation.font_size; // 默认字体 + } + }) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + + // 检查宽度，如果太小或值为0则不显示 + if (width < 5 || value <= 0) return ""; + + // 只在值大于0时显示 + return chartUtils.format.autoText(value) + (yUnit ? yUnit : ''); + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .style("fill", "#ffffff") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()); + + // 移除Y轴上的所有文本标签 + yAxis.selectAll(".tick text").remove(); + + // 添加X标签到条形图上方 + processedData.forEach(d => { + chartGroup.append("text") + .attr("x", 0) // 与条形图左端对齐 + .attr("y", yScale(d.period) - 10) // 放在条形图上方10px + .style("text-anchor", "start") + .style("fill", "#ffffff") // 改为白色字体 + .style("font-size", "15px") // 15px字体大小 + .style("font-family", typography.label.font_family) + .text(d.period); + }); + + // 移除原始Y轴标签和背景 + // yAxis.selectAll(".tick text").remove(); // 删除这一行，因为上面已经移除 + + let bandWidth = yScale.bandwidth(); + let iconSize = yScale.bandwidth() * 0.7; + + // 在右侧添加图标，缩短与条形图的距离 + if (jsonData.images) { + chartGroup.selectAll(".icon") + .data(processedData) + .enter() + .append("image") + .attr("class", "icon") + .attr("x", chartWidth + 5) // 放在条形图右侧，距离缩短为原来的一半 + .attr("y", d => yScale(d.period) + (yScale.bandwidth() - iconSize) / 2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", d => jsonData.images.field[d.period]); + } + + // 移除图例部分 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_0.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_0.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..2b00c3cdc5aa8d940ac6eacd1a1ec7f86dbc5cce --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_0.js.bug @@ -0,0 +1,305 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Pictorial Bar Chart", + "chart_name": "horizontal_stacked_pictorial_bar_chart_0", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 100], [3, 20]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + +// 提取数据和配置 +const jsonData = data; // 完整的JSON数据对象 +const chartData = jsonData.data.data; // 实际数据点数组 +const variables = jsonData.variables || {}; // 图表配置 +const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } +}; +const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } +}; // 颜色设置 +const dataColumns = jsonData.data.columns || []; // 数据列定义 + +// 添加数值格式化函数 +const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } +}; + +// 设置视觉效果变量的默认值 +variables.has_shadow = variables.has_shadow || false; +variables.has_stroke = variables.has_stroke || false; + +// 清空容器 +d3.select(containerSelector).html(""); + +// ---------- 2. 尺寸和布局设置 ---------- + +// 设置图表总尺寸 +const width = variables.width || 600; +const height = variables.height || 400; + +// 设置边距 +const margin = { + top: 50, + right: 30, + bottom: 80, + left: 200 +}; + +// 计算实际绘图区域大小 +const chartWidth = width - margin.left - margin.right; +const chartHeight = height - margin.top - margin.bottom; + +// ---------- 3. 提取字段名和单位 ---------- + +// 根据数据列获取字段名 +const xField = dataColumns.find(col => col.role === "x")?.name || "period"; +const yField = dataColumns.find(col => col.role === "y")?.name || "value"; +const groupField = dataColumns.find(col => col.role === "group")?.name || "status"; + +// 获取字段单位（如果存在） +let xUnit = ""; +let yUnit = ""; +let groupUnit = ""; + +if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; +} + +if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; +} + +if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; +} + +// ---------- 4. 数据处理 ---------- + +// 获取所有唯一的组值 +const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + +// 处理数据为堆叠格式 +const groupedData = d3.group(chartData, d => d[xField]); +const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + return obj; +}); + +// 创建堆叠生成器 +const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + +// 生成堆叠数据 +const stackedData = stack(processedData); + +// ---------- 5. 创建比例尺 ---------- + +// Y轴比例尺 - 使用时间段作为分类 +const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.3); + +// X轴比例尺 - 使用数值 +const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, chartWidth]) + .nice(); + +// 根据colors.field的值，获取对应的color +let group_colors = [] +for (let i = 0; i < groups.length; i++) { + group_colors.push(colors.field[groups[i]]) +} +// 颜色比例尺 +const colorScale = d3.scaleOrdinal() + .domain(groups) + .range(group_colors) + + + +// ---------- 6. 创建SVG容器 ---------- + +const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + +// 添加图表主体容器 +const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + +// ---------- 7. 绘制图表元素 ---------- + +// 绘制堆叠的条形 +const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("image") + .data(d => d) + .enter().append("image") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .attr("xlink:href", d => { + let gap = d[1]-d[0] + // 从d.data中找到gap对应的key + for (let key in d.data) { + if (Math.abs(d.data[key] - gap) < 0.0001) { + return jsonData.images.field[key] + } + } + }) + .attr("preserveAspectRatio", "none") + +// 添加数值标注 +layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const textwidth = getTextWidth(formatValue(value) + (yUnit ? yUnit : ''), typography.annotation.font_size) + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formatValue(value) + (yUnit ? yUnit : '') : ''; + }); + +// 添加X轴 +const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + +// 添加Y轴 +const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()) +yAxis.selectAll("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + +let bandWidth = yScale.bandwidth() +let iconSize = yScale.bandwidth()*0.7 +let iconPadding = 10; +// 添加文本和图标 +yAxis.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + if(jsonData.images && jsonData.images.field[d]) { + tick.append("image") + .attr("x", - iconSize - iconPadding) // 10是原有的padding + .attr("y", -iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[d]); + tick.select("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("x", -iconSize-2*iconPadding) + } +}); + +// 添加图例 - 放在图表上方 +const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + +// 计算字段名宽度并添加间距 +const titleWidth = groupField.length * 10; +const titleMargin = 15; + + +const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", +}); + +// 添加字段名称 +legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + +// 将图例组向上移动 height/2, 并居中 +legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + +return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_1.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_1.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..5debff64cbcf26b6cfbffc0898e887989f2f0c75 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_stacked_pictorial_bar_chart_1.js.bug @@ -0,0 +1,298 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Stacked Pictorial Bar Chart", + "chart_name": "horizontal_stacked_pictorial_bar_chart_1", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[3, 20], [0, 100], [3, 20]], + "required_fields_icons": ["group"], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#D32F2F", // Red for "Still active" + secondary: "#AAAAAA", // Gray for "Ended" + background: "#F0F0F0" + } + }; // 颜色设置 + const dataColumns = jsonData.data.columns || []; // 数据列定义 + + // 添加数值格式化函数 + const formatValue = (value) => { + if (value >= 1000000000) { + return d3.format("~g")(value / 1000000000) + "B"; + } else if (value >= 1000000) { + return d3.format("~g")(value / 1000000) + "M"; + } else if (value >= 1000) { + return d3.format("~g")(value / 1000) + "K"; + } else { + return d3.format("~g")(value); + } + }; + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 200 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = dataColumns.find(col => col.role === "x")?.name || "period"; + const yField = dataColumns.find(col => col.role === "y")?.name || "value"; + const groupField = dataColumns.find(col => col.role === "group")?.name || "status"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (dataColumns.find(col => col.role === "x")?.unit !== "none") { + xUnit = dataColumns.find(col => col.role === "x").unit; + } + + if (dataColumns.find(col => col.role === "y")?.unit !== "none") { + yUnit = dataColumns.find(col => col.role === "y").unit; + } + + if (dataColumns.find(col => col.role === "group")?.unit !== "none") { + groupUnit = dataColumns.find(col => col.role === "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据为堆叠格式 + const groupedData = d3.group(chartData, d => d[xField]); + const processedData = Array.from(groupedData, ([key, values]) => { + const obj = { period: key }; + groups.forEach(group => { + obj[group] = d3.sum(values.filter(d => d[groupField] === group), d => +d[yField]); + }); + obj.total = d3.sum(values, d => +d[yField]); + obj.icon = jsonData.images.field[key]; + return obj; + }); + + // 创建堆叠生成器 + const stack = d3.stack() + .keys(groups) + .order(d3.stackOrderNone) + .offset(d3.stackOffsetNone); + + // 生成堆叠数据 + const stackedData = stack(processedData); + + // ---------- 5. 创建比例尺 ---------- + + // Y轴比例尺 - 使用时间段作为分类 + const yScale = d3.scaleBand() + .domain(processedData.map(d => d.period)) + .range([chartHeight, 0]) + .padding(0.3); + + // X轴比例尺 - 使用数值 + const xScale = d3.scaleLinear() + .domain([0, d3.max(processedData, d => d.total)]) + .range([0, chartWidth]) + .nice(); + + // 根据colors.field的值，获取对应的color + let group_colors = [] + for (let i = 0; i < groups.length; i++) { + group_colors.push(colors.field[groups[i]]) + } + // 颜色比例尺 + const colorScale = d3.scaleOrdinal() + .domain(groups) + .range(group_colors) + + + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 绘制堆叠的条形 + const layers = chartGroup.selectAll(".layer") + .data(stackedData) + .enter().append("g") + .attr("class", "layer") + .style("fill", (d) => colorScale(d.key)); + + layers.selectAll("image") + .data(d => d) + .enter().append("image") + .attr("y", d => yScale(d.data.period)) + .attr("x", d => xScale(d[0])) + .attr("width", d => xScale(d[1]) - xScale(d[0])) + .attr("height", yScale.bandwidth()) + .attr("xlink:href", d => d.icon) + .attr("preserveAspectRatio", "none"); + + // 添加数值标注 + layers.selectAll("text") + .data(d => d) + .enter().append("text") + .attr("y", d => yScale(d.data.period) + yScale.bandwidth() / 2) + .attr("x", d => { + const width = xScale(d[1]) - xScale(d[0]); + return xScale(d[0]) + width / 2; + }) + .attr("text-anchor", "middle") + .attr("dominant-baseline", "middle") + .style("fill", "#ffffff") + .style("font-family", typography.annotation.font_family) + .style("font-size", typography.annotation.font_size) + .text(d => { + const value = d[1] - d[0]; + const width = xScale(d[1]) - xScale(d[0]); + const textwidth = getTextWidth(formatValue(value) + (yUnit ? yUnit : ''), typography.annotation.font_size) + // 只在宽度大于文本宽度且值大于0时显示文本 + return (width > textwidth && value > 0) ? formatValue(value) + (yUnit ? yUnit : '') : ''; + }); + + // 添加X轴 + const xAxis = chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(d3.axisBottom(xScale) + .tickSize(0) + .tickPadding(10)) + .call(g => g.select(".domain").remove()) + .selectAll("text") + .remove(); + + // 添加Y轴 + const yAxis = chartGroup.append("g") + .attr("class", "y-axis") + .call(d3.axisLeft(yScale) + .tickSize(0) + .tickPadding(10) + .tickFormat(d => d)) + .call(g => g.select(".domain").remove()) + yAxis.selectAll("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colors.text_color); + + let bandWidth = yScale.bandwidth() + let iconSize = yScale.bandwidth()*0.7 + let iconPadding = 10; + // 添加文本和图标 + yAxis.selectAll(".tick").each(function(d) { + const tick = d3.select(this); + if(jsonData.images && jsonData.images.field[d]) { + tick.append("image") + .attr("x", - iconSize - iconPadding) // 10是原有的padding + .attr("y", -iconSize/2) + .attr("width", iconSize) + .attr("height", iconSize) + .attr("xlink:href", jsonData.images.field[d]); + tick.select("text") + .style("text-anchor", "end") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .attr("x", -iconSize-2*iconPadding) + } + }); + + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = layoutLegend(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + // 添加字段名称 + legendGroup.append("text") + .attr("x", 0) + .attr("y", legendSize.height / 2) + .attr("dominant-baseline", "middle") + .attr("fill", "#333") + .style("font-size", "16px") + .style("font-weight", "bold") + .text(groupField); + + // 将图例组向上移动 height/2, 并居中 + legendGroup.attr("transform", `translate(${(chartWidth - legendSize.width - titleWidth - titleMargin) / 2}, 0)`); + + + return svg.node(); +} \ No newline at end of file diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_01.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_01.js new file mode 100644 index 0000000000000000000000000000000000000000..ddf2e2df347242bffd3dfeb988c69615500e9982 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_01.js @@ -0,0 +1,292 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Waffle Chart", + "chart_name": "horizontal_waffle_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 单位方块图实现 - 使用小方块表示数据值 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const fontSize = chartUtils.text.fontSize; + const colors = jsonData.colors || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + }; + + // 添加数值格式化函数 + + // 提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit || ""; + + // ---------- 2. 配置图表参数 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + // 初始设置图表边距，后续会在绘制方块图后调整 + const margin = { + top: 100, // 临时值，后续会根据图例高度调整 + right: 30, + bottom: 40, + left: 30 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 计算单位方块数和大小 ---------- + // 计算数据总和 + const totalValue = chartData.reduce((sum, d) => sum + (+d[yField] || 0), 0); + + // 确定单位方块的总数（目标是500-1000个） + let totalSquares = totalValue; + let valuePerSquare = 1; + + // 调整每个方块代表的值，确保方块总数在500-1000之间 + if (totalValue > 1000) { + // 如果总数太大，增加每个方块的值 + valuePerSquare = Math.ceil(totalValue / 800); // 目标800个方块 + totalSquares = Math.ceil(totalValue / valuePerSquare); + } else if (totalValue < 300) { + // 如果总数太小，减少每个方块的值（允许代表小于1的数值） + valuePerSquare = totalValue / 300; // 目标300个方块 + totalSquares = 300; // 固定方块数量 + } + + // 根据画布比例确定最适合的行列数，使方块更好地填充空间 + // 计算画布的宽高比 + const canvasRatio = innerWidth / innerHeight; + + // 计算最接近画布比例的行列组合 + // 这里采用开平方，然后根据画布比例调整的方式 + const sqrtSquares = Math.sqrt(totalSquares); + // 对于水平布局，我们交换行列的计算方式 + let numRows = Math.round(sqrtSquares / Math.sqrt(canvasRatio)); + let numCols = Math.round(sqrtSquares * Math.sqrt(canvasRatio)); + + // 确保行列乘积不少于总方块数 + while (numRows * numCols < totalSquares) { + if (numCols / numRows < canvasRatio) { + numCols++; + } else { + numRows++; + } + } + + // 确保至少有一行一列 + numRows = Math.max(1, numRows); + numCols = Math.max(1, numCols); + + // 计算方块大小，确保完全填充可用空间 + // 首先计算可用于每个方块的空间 + const maxSquareWidth = innerWidth / numCols; + const maxSquareHeight = innerHeight / numRows; + + // 使用较小的尺寸确保方块是正方形 + const maxSquareSize = Math.min(maxSquareWidth, maxSquareHeight); + + // 为了留出一些间距，使方块略小于可用空间 + const squareSize = maxSquareSize * 0.85; // 稍微减小方块以增加间距 + const squareSpacing = maxSquareSize * 0.15; // 增加间距使布局更美观 + + // 重新计算基于优化后的方块大小实际使用的空间 + const actualChartWidth = numCols * maxSquareSize; + const actualChartHeight = numRows * maxSquareSize; + + // 计算方块图的偏移量以居中显示 + const offsetX = (innerWidth - actualChartWidth) / 2; + const offsetY = (innerHeight - actualChartHeight) / 2; + + // ---------- 4. 创建SVG容器 ---------- + // 清除容器 + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 5. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 1); + + filter.append("feOffset") + .attr("dx", 1) + .attr("dy", 1) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 6. 创建图表区域 ---------- + // 创建一个容器，后续再添加实际内容 + const containerGroup = svg.append("g"); + + // ---------- 7. 计算各类别的数据 ---------- + // 计算每个类别所需的方块数和起始位置 + const categorySquares = []; + let squareCount = 0; + + // 用于颜色分配 + const categoryColors = {}; + + // 如果没有为每个类别指定颜色，使用默认颜色方案 + const defaultColors = colorResolver.availablePalette(6, { + fallbackColors: ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#ff8ab7", "#97bbf5"], + }); + + chartData.forEach((d, i) => { + const category = d[xField]; + const value = +d[yField]; + const numSquares = Math.round(value / valuePerSquare); + + // 确保每个类别有颜色 + categoryColors[category] = colorResolver.field(category, i, { colors: defaultColors }).value; + + categorySquares.push({ + category: category, + value: value, + squares: numSquares, + startSquare: squareCount, + color: categoryColors[category] + }); + + squareCount += numSquares; + }); + const availableLegendWidth = innerWidth; + const legendSquareSize = 14; + const legendRowHeight = Math.max(36, fontSize(typography.label.font_size) * 2.4); + const legendSpacing = 12; + + const legendItemsForDraw = chartData.map((d, i) => ({ + label: d[xField], + valueLabel: `${chartUtils.format.autoText(+d[yField])} ${yUnit}`, + color: categoryColors[d[xField]], + raw: d, + })); + const legendDrawResult = chartUtils.legend.categoryValueRows(svg, legendItemsForDraw, { + maxWidth: availableLegendWidth, + markerSize: legendSquareSize, + rowHeight: legendRowHeight, + itemGap: legendSpacing, + fontSize: fontSize(typography.label.font_size), + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + valueFontWeight: "bold", + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? Math.max(1, legendSquareSize * 0.15) : 0, + }); + const actualLegendHeight = legendDrawResult.height; + // 根据实际图例高度，调整图表布局 + // 图例在上方，方块图在下方，两者之间留出10px的间距 + const legendVerticalSpace = 10; // 图例和方块图之间的间距 + + // 计算方块图的顶部位置，考虑图例高度和间距 + const chartTopPosition = actualLegendHeight + legendVerticalSpace; + + // 计算方块图需要的总高度 + const chartTotalHeight = actualChartHeight + 2 * offsetY; + + // 使方块图居中显示（垂直方向） + const verticalCenterOffset = (height - chartTopPosition - chartTotalHeight) / 2; + const finalChartTopPosition = chartTopPosition + Math.max(0, verticalCenterOffset); + + // 移动图例到适当位置 + legendDrawResult.group.attr("transform", `translate(${margin.left}, 20)`); + + // ---------- 9. 绘制所有单位方块 ---------- + // 创建方块图区域，位于图例下方 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left + offsetX}, ${finalChartTopPosition})`); + + // 为每个类别创建方块组 + // 创建一个二维数组表示方块的位置占用情况 + const occupiedPositions = Array(numRows).fill().map(() => Array(numCols).fill(false)); + let squareIndex = 0; + + // 为每个类别创建方块 + categorySquares.forEach(cat => { + // 创建该类别的所有方块 + for (let i = 0; i < cat.squares; i++) { + if (squareIndex >= numRows * numCols) break; // 防止越界 + + // 先从左到右，再从上到下计数（水平布局） + const row = Math.floor(squareIndex / numCols); + const col = squareIndex % numCols; + + occupiedPositions[row][col] = true; + + chart.append("rect") + .attr("data-category", cat.category) // 添加数据属性，方便交互 + .attr("x", col * maxSquareSize + squareSpacing / 2) + .attr("y", row * maxSquareSize + squareSpacing / 2) + .attr("width", squareSize) + .attr("height", squareSize) + .attr("fill", cat.color) + .attr("rx", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? Math.max(0.5, squareSize * 0.05) : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + squareIndex++; + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_02.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_02.js new file mode 100644 index 0000000000000000000000000000000000000000..982c2990d5f44629ff2731aa508cff7a94c994f3 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/horizontal_waffle_chart_02.js @@ -0,0 +1,293 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Horizontal Waffle Chart", + "chart_name": "horizontal_waffle_chart_02", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 20], [0, "inf"]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["x"], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "stroke"], + "min_height": 400, + "min_width": 400, + "background": "dark", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 单位方块图实现 - 使用小方块表示数据值 +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备 ---------- + // 提取数据和配置 + const jsonData = data; + const chartData = jsonData.data.data || []; + const variables = jsonData.variables || {}; + const typography = jsonData.typography || { + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const fontSize = chartUtils.text.fontSize; + const colors = jsonData.colors_dark || { + text_color: "#333333", + field: {}, + other: { + primary: "#4682B4" // 默认主色调 + } + } + variables.has_rounded_corners = 1 + + // 添加数值格式化函数 + + // 提取字段名称 + const xChannel = chartUtils.schema.channel(jsonData, "x", { fallbackIndex: 0 }); + const yChannel = chartUtils.schema.channel(jsonData, "y", { fallbackIndex: 1 }); + const xField = xChannel.key; + const yField = yChannel.key; + const yUnit = yChannel.unit || ""; + + // ---------- 2. 配置图表参数 ---------- + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + // 初始设置图表边距，后续会在绘制方块图后调整 + const margin = { + top: 100, // 临时值，后续会根据图例高度调整 + right: 30, + bottom: 40, + left: 30 + }; + + // 计算实际绘图区域大小 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 计算单位方块数和大小 ---------- + // 计算数据总和 + const totalValue = chartData.reduce((sum, d) => sum + (+d[yField] || 0), 0); + + // 确定单位方块的总数（目标是500-1000个） + let totalSquares = totalValue; + let valuePerSquare = 1; + + // 调整每个方块代表的值，确保方块总数在500-1000之间 + if (totalValue > 1000) { + // 如果总数太大，增加每个方块的值 + valuePerSquare = Math.ceil(totalValue / 800); // 目标800个方块 + totalSquares = Math.ceil(totalValue / valuePerSquare); + } else if (totalValue < 300) { + // 如果总数太小，减少每个方块的值（允许代表小于1的数值） + valuePerSquare = totalValue / 300; // 目标300个方块 + totalSquares = 300; // 固定方块数量 + } + + // 根据画布比例确定最适合的行列数，使方块更好地填充空间 + // 计算画布的宽高比 + const canvasRatio = innerWidth / innerHeight; + + // 计算最接近画布比例的行列组合 + // 这里采用开平方，然后根据画布比例调整的方式 + const sqrtSquares = Math.sqrt(totalSquares); + // 对于水平布局，我们交换行列的计算方式 + let numRows = Math.round(sqrtSquares / Math.sqrt(canvasRatio)); + let numCols = Math.round(sqrtSquares * Math.sqrt(canvasRatio)); + + // 确保行列乘积不少于总方块数 + while (numRows * numCols < totalSquares) { + if (numCols / numRows < canvasRatio) { + numCols++; + } else { + numRows++; + } + } + + // 确保至少有一行一列 + numRows = Math.max(1, numRows); + numCols = Math.max(1, numCols); + + // 计算方块大小，确保完全填充可用空间 + // 首先计算可用于每个方块的空间 + const maxSquareWidth = innerWidth / numCols; + const maxSquareHeight = innerHeight / numRows; + + // 使用较小的尺寸确保方块是正方形 + const maxSquareSize = Math.min(maxSquareWidth, maxSquareHeight); + + // 为了留出一些间距，使方块略小于可用空间 + const squareSize = maxSquareSize * 0.85; // 稍微减小方块以增加间距 + const squareSpacing = maxSquareSize * 0.15; // 增加间距使布局更美观 + + // 重新计算基于优化后的方块大小实际使用的空间 + const actualChartWidth = numCols * maxSquareSize; + const actualChartHeight = numRows * maxSquareSize; + + // 计算方块图的偏移量以居中显示 + const offsetX = (innerWidth - actualChartWidth) / 2; + const offsetY = (innerHeight - actualChartHeight) / 2; + + // ---------- 4. 创建SVG容器 ---------- + // 清除容器 + d3.select(containerSelector).html(""); + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // ---------- 5. 创建视觉效果 ---------- + const defs = svg.append("defs"); + + // 如果需要，创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 1); + + filter.append("feOffset") + .attr("dx", 1) + .attr("dy", 1) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // ---------- 6. 创建图表区域 ---------- + // 创建一个容器，后续再添加实际内容 + const containerGroup = svg.append("g"); + + // ---------- 7. 计算各类别的数据 ---------- + // 计算每个类别所需的方块数和起始位置 + const categorySquares = []; + let squareCount = 0; + + // 用于颜色分配 + const categoryColors = {}; + + // 如果没有为每个类别指定颜色，使用默认颜色方案 + const defaultColors = colorResolver.availablePalette(6, { + fallbackColors: ["#4269d0", "#efb118", "#ff725c", "#6cc5b0", "#ff8ab7", "#97bbf5"], + }); + + chartData.forEach((d, i) => { + const category = d[xField]; + const value = +d[yField]; + const numSquares = Math.round(value / valuePerSquare); + + // 确保每个类别有颜色 + categoryColors[category] = colorResolver.field(category, i, { colors: defaultColors }).value; + + categorySquares.push({ + category: category, + value: value, + squares: numSquares, + startSquare: squareCount, + color: categoryColors[category] + }); + + squareCount += numSquares; + }); + const availableLegendWidth = innerWidth; + const legendSquareSize = 14; + const legendRowHeight = Math.max(36, fontSize(typography.label.font_size) * 2.4); + const legendSpacing = 12; + + const legendItemsForDraw = chartData.map((d, i) => ({ + label: d[xField], + valueLabel: `${chartUtils.format.autoText(+d[yField])} ${yUnit}`, + color: categoryColors[d[xField]], + raw: d, + })); + const legendDrawResult = chartUtils.legend.categoryValueRows(svg, legendItemsForDraw, { + maxWidth: availableLegendWidth, + markerSize: legendSquareSize, + rowHeight: legendRowHeight, + itemGap: legendSpacing, + fontSize: fontSize(typography.label.font_size), + fontFamily: typography.label.font_family, + fontWeight: typography.label.font_weight, + valueFontWeight: "bold", + textColor: colorResolver.text({ fallback: "#333333" }).value, + markerRadius: variables.has_rounded_corners ? Math.max(1, legendSquareSize * 0.15) : 0, + }); + const actualLegendHeight = legendDrawResult.height; + // 根据实际图例高度，调整图表布局 + // 图例在上方，方块图在下方，两者之间留出10px的间距 + const legendVerticalSpace = 10; // 图例和方块图之间的间距 + + // 计算方块图的顶部位置，考虑图例高度和间距 + const chartTopPosition = actualLegendHeight + legendVerticalSpace; + + // 计算方块图需要的总高度 + const chartTotalHeight = actualChartHeight + 2 * offsetY; + + // 使方块图居中显示（垂直方向） + const verticalCenterOffset = (height - chartTopPosition - chartTotalHeight) / 2; + const finalChartTopPosition = chartTopPosition + Math.max(0, verticalCenterOffset); + + // 移动图例到适当位置 + legendDrawResult.group.attr("transform", `translate(${margin.left}, 20)`); + + // ---------- 9. 绘制所有单位方块 ---------- + // 创建方块图区域，位于图例下方 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left + offsetX}, ${finalChartTopPosition})`); + + // 为每个类别创建方块组 + // 创建一个二维数组表示方块的位置占用情况 + const occupiedPositions = Array(numRows).fill().map(() => Array(numCols).fill(false)); + let squareIndex = 0; + + // 为每个类别创建方块 + categorySquares.forEach(cat => { + // 创建该类别的所有方块 + for (let i = 0; i < cat.squares; i++) { + if (squareIndex >= numRows * numCols) break; // 防止越界 + + // 先从左到右，再从上到下计数（水平布局） + const row = Math.floor(squareIndex / numCols); + const col = squareIndex % numCols; + + occupiedPositions[row][col] = true; + + chart.append("rect") + .attr("data-category", cat.category) // 添加数据属性，方便交互 + .attr("x", col * maxSquareSize + squareSpacing / 2) + .attr("y", row * maxSquareSize + squareSpacing / 2) + .attr("width", squareSize) + .attr("height", squareSize) + .attr("fill", cat.color) + .attr("rx", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) + .attr("ry", variables.has_rounded_corners ? Math.max(1, squareSize * 0.1) : 0) + .attr("stroke", variables.has_stroke ? "#555" : "none") + .attr("stroke-width", variables.has_stroke ? Math.max(0.5, squareSize * 0.05) : 0) + .style("filter", variables.has_shadow ? "url(#shadow)" : "none"); + + squareIndex++; + } + }); + + // 返回SVG节点 + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_group_bar_chart_2.js b/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_group_bar_chart_2.js new file mode 100644 index 0000000000000000000000000000000000000000..0c4bbf7613886acdd5c32708143c91bc28f72206 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_group_bar_chart_2.js @@ -0,0 +1,278 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Group Bar Chart", + "chart_name": "vertical_group_bar_chart_14", + "required_fields": ["x", "y", "group"], + "required_fields_type": [["categorical"], ["numerical"], ["categorical"]], + "required_fields_range": [[2,4], [0, 100], [2,2]], + "required_fields_icons": [], + "required_other_icons": [], + "required_fields_colors": ["group"], + "required_other_colors": ["primary", "secondary", "background"], + "supported_effects": ["gradient", "opacity"], + "min_height": 600, + "min_width": 800, + "background": "light", + "icon_mark": "none", + "icon_label": "none", + "has_x_axis": "yes", + "has_y_axis": "yes" +} +REQUIREMENTS_END +*/ + + +function makeChart(containerSelector, data) { + const colorResolver = chartUtils.color.resolver(data); + // ---------- 1. 数据准备阶段 ---------- + + // 提取数据和配置 + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data; // 实际数据点数组 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置，如果不存在则使用默认值 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { + primary: "#1f77b4", // 蓝色 + secondary: "#2ca02c", // 绿色 + background: "#FFFFFF" + } + }; // 颜色设置 + const dataColumns = chartUtils.schema.columns(jsonData); // 数据列定义 + + // 添加数值格式化函数 + + // 设置视觉效果变量的默认值 + variables.has_shadow = variables.has_shadow || false; + variables.has_stroke = variables.has_stroke || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表总尺寸 + const width = variables.width || 600; + const height = variables.height || 400; + + // 设置边距 + const margin = { + top: 50, + right: 30, + bottom: 80, + left: 40 + }; + + // 计算实际绘图区域大小 + const chartWidth = width - margin.left - margin.right; + const chartHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名和单位 ---------- + + // 根据数据列获取字段名 + const xField = chartUtils.schema.channel(jsonData, "x").key || "period"; + const yField = chartUtils.schema.channel(jsonData, "y").key || "value"; + const groupField = chartUtils.schema.channel(jsonData, "group").key || "group"; + + // 获取字段单位（如果存在） + let xUnit = ""; + let yUnit = ""; + let groupUnit = ""; + + if (chartUtils.schema.channel(jsonData, "x").unit !== "none") { + xUnit = chartUtils.schema.channel(jsonData, "x").unit; + } + + if (chartUtils.schema.channel(jsonData, "y").unit !== "none") { + yUnit = chartUtils.schema.channel(jsonData, "y").unit; + } + + if (chartUtils.schema.channel(jsonData, "group").unit !== "none") { + groupUnit = chartUtils.schema.channel(jsonData, "group").unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取所有唯一的分组值 + const groups = Array.from(new Set(chartData.map(d => d[groupField]))); + + // 处理数据，按照分组组织 + const processedData = chartData.reduce((acc, d) => { + const category = d[xField]; + const group = d[groupField]; + const value = +d[yField]; + + const existingCategory = acc.find(item => item.category === category); + if (existingCategory) { + existingCategory.groups[group] = value; + } else { + const newCategory = { + category: category, + groups: {} + }; + newCategory.groups[group] = value; + acc.push(newCategory); + } + return acc; + }, []); + + // ---------- 5. 创建比例尺 ---------- + + // X轴比例尺 - 使用分类数据 + const xScale = d3.scaleBand() + .domain(processedData.map(d => d.category)) + .range([0, chartWidth]) + .padding(0.4); + + // 分组比例尺 + const groupScale = d3.scaleBand() + .domain(groups) + .range([0, xScale.bandwidth()]) + .padding(0); + + // Y轴比例尺 - 使用数值 + const yScale = d3.scaleLinear() + .domain([0, d3.max(chartData, d => +d[yField])]) + .range([chartHeight, 0]) + .nice(); + + // // 颜色比例尺 + // const colorScale = d3.scaleOrdinal() + // .domain(groups) + // .range(d3.schemeCategory10); + + // 确定标签的最大长度： + let minXLabelRatio = 1.0; + const maxXLabelWidth = xScale.bandwidth() * 1.03; + + chartData.forEach(d => { + // x label + const xLabelText = String(d[xField]); + let currentWidth = chartUtils.text.measure(null, xLabelText).width; + if (currentWidth > maxXLabelWidth) { + minXLabelRatio = Math.min(minXLabelRatio, maxXLabelWidth / currentWidth); + } + }); + + // ---------- 6. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + // 添加图表主体容器 + const chartGroup = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // ---------- 7. 绘制图表元素 ---------- + + // 添加X轴 + const xAxis = d3.axisBottom(xScale) + .tickSize(0); // 移除刻度线 + + chartGroup.append("g") + .attr("class", "x-axis") + .attr("transform", `translate(0, ${chartHeight})`) + .call(xAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("text-anchor", minXLabelRatio < 1.0 ? "end" : "middle") + .attr("transform", minXLabelRatio < 1.0 ? "rotate(-45)" : "rotate(0)") + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 添加Y轴 + const yAxis = d3.axisLeft(yScale) + .ticks(5) + .tickFormat(d => chartUtils.format.autoText(d) + (yUnit ? ` ${yUnit}` : '')) + .tickSize(0) // 移除刻度线 + .tickPadding(10); // 增加文字和轴的间距 + + chartGroup.append("g") + .attr("class", "y-axis") + .call(yAxis) + .selectAll("text") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value); + + // 修改条形图绘制部分 + const barGroups = chartGroup.selectAll(".bar-group") + .data(processedData) + .enter() + .append("g") + .attr("class", "bar-group") + .attr("transform", d => `translate(${xScale(d.category)},0)`); + + // 反转groups数组以确保正确的绘制顺序 + const reversedGroups = [...groups].reverse(); + + + reversedGroups.forEach(group => { + // 主柱子 + barGroups.append("path") + .attr("class", "bar") + .attr("d", d => { + const x = groupScale(group) - groupScale.bandwidth() * 0.2; + const y = yScale(d.groups[group] || 0); + const width = groupScale.bandwidth() * 1.8; + const height = chartHeight - yScale(d.groups[group] || 0); + const skewOffset = width * 0.25; + + return ` + M ${x} ${y} + L ${x + width} ${y + skewOffset} + L ${x + width} ${y + height} + L ${x} ${y + height - skewOffset} + Z + `; + }) + .attr("fill", colorResolver.other(group === groups[0] ? "primary" : "secondary", { + index: groups.indexOf(group), + }).value) + .style("opacity", 0.7); + + // 数值标签 + barGroups.append("text") + .attr("class", "value-label") + .attr("x", d => groupScale(group) + groupScale.bandwidth() * 0.7) + .attr("y", d => yScale(d.groups[group] || 0) - 8) + .attr("text-anchor", "middle") + .style("font-family", typography.label.font_family) + .style("font-size", typography.label.font_size) + .style("fill", colorResolver.text({ fallback: "#333333" }).value) + .text(d => `${chartUtils.format.autoText(d.groups[group] || 0)}${yUnit}`); + }); + // 添加图例 - 放在图表上方 + const legendGroup = svg.append("g") + .attr("transform", `translate(0, -50)`); + + // 计算字段名宽度并添加间距 + const titleWidth = groupField.length * 10; + const titleMargin = 15; + + + const legendSize = chartUtils.legend.draw(legendGroup, groups, colors, { + x: titleWidth + titleMargin, + y: 0, + fontSize: 14, + fontWeight: "bold", + align: "left", + maxWidth: chartWidth - titleWidth - titleMargin, + shape: "rect", + }); + + return svg.node(); +} diff --git a/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_pictorial_bar_chart_01.js.bug b/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_pictorial_bar_chart_01.js.bug new file mode 100644 index 0000000000000000000000000000000000000000..0139337bdb19c127a3764758058bab40ec172224 --- /dev/null +++ b/modules/chart_engine/template/d3-js/bar_chart_horizontal/vertical_pictorial_bar_chart_01.js.bug @@ -0,0 +1,476 @@ +/* +REQUIREMENTS_BEGIN +{ + "chart_type": "Vertical Pictorial Bar Chart", + "chart_name": "vertical_pictorial_bar_chart_01", + "is_composite": false, + "required_fields": ["x", "y"], + "required_fields_type": [["categorical"], ["numerical"]], + "required_fields_range": [[2, 12], [0, "inf"]], + "required_fields_icons": ["x"], + "required_other_icons": [], + "required_fields_colors": [], + "required_other_colors": ["primary"], + "supported_effects": ["shadow", "radius_corner", "gradient", "stroke", "spacing"], + "min_height": 400, + "min_width": 400, + "background": "no", + "icon_mark": "none", + "icon_label": "side", + "has_x_axis": "no", + "has_y_axis": "no" +} +REQUIREMENTS_END +*/ + +// 使用D3.js创建简单的垂直条形图 +function makeChart(containerSelector, data) { + // ---------- 1. 数据准备 ---------- + const jsonData = data; // 完整的JSON数据对象 + const chartData = jsonData.data.data || []; // 图表数据 + const variables = jsonData.variables || {}; // 图表配置 + const typography = jsonData.typography || { // 字体设置 + title: { font_family: "Arial", font_size: "18px", font_weight: "bold" }, + label: { font_family: "Arial", font_size: "12px", font_weight: "normal" }, + description: { font_family: "Arial", font_size: "14px", font_weight: "normal" }, + annotation: { font_family: "Arial", font_size: "12px", font_weight: "normal" } + }; + const colors = jsonData.colors || { + text_color: "#333333", + other: { primary: "#73D2C7", secondary: "#4682B4" } + }; + const images = jsonData.images || { field: {}, other: {} }; // 图片(标志等) + const dataColumns = jsonData.data.columns || []; // 数据列 + + // 设置视觉效果变量 + variables.has_rounded_corners = variables.has_rounded_corners || false; + variables.has_shadow = variables.has_shadow || false; + variables.has_gradient = variables.has_gradient || false; + variables.has_stroke = variables.has_stroke || false; + variables.has_spacing = variables.has_spacing || false; + + // 清空容器 + d3.select(containerSelector).html(""); + + // ---------- 2. 尺寸和布局设置 ---------- + + // 设置图表尺寸和边距 + const width = variables.width || 800; + const height = variables.height || 600; + + // 边距: 上, 右, 下, 左 + const margin = { + top: 60, // 柱子上方数值标签的空间 + right: 30, + bottom: 150, // x轴和图标的空间 + left: 60 + }; + + // 计算实际图表区域尺寸 + const innerWidth = width - margin.left - margin.right; + const innerHeight = height - margin.top - margin.bottom; + + // ---------- 3. 提取字段名称和单位 ---------- + + let xField, yField; + let xUnit = "", yUnit = ""; + + // 安全提取字段名称 + const xColumn = dataColumns.find(col => col.role === "x"); + const yColumn = dataColumns.find(col => col.role === "y"); + + if (xColumn) xField = xColumn.name; + if (yColumn) yField = yColumn.name; + + // 获取字段单位(如果存在) + if (xColumn && xColumn.unit && xColumn.unit !== "none") { + xUnit = xColumn.unit; + } + + if (yColumn && yColumn.unit && yColumn.unit !== "none") { + yUnit = yColumn.unit; + } + + // ---------- 4. 数据处理 ---------- + + // 获取唯一的x轴值 + const xValues = [...new Set(chartData.map(d => d[xField]))]; + + // 创建按y值降序排序的数据 + const sortedData = chartData.map(d => ({ + x: d[xField], + y: +d[yField], // 确保y是数值类型 + icon: jsonData.images.field[d[xField]] + })).sort((a, b) => b.y - a.y); + + // ---------- 5. 创建SVG容器 ---------- + + const svg = d3.select(containerSelector) + .append("svg") + .attr("width", "100%") + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .attr("style", "max-width: 100%; height: auto;") + .attr("xmlns", "http://www.w3.org/2000/svg") + .attr("xmlns:xlink", "http://www.w3.org/1999/xlink"); + + + + // ---------- 6. 创建视觉效果 ---------- + + const defs = svg.append("defs"); + + // 获取颜色函数 + const getColor = () => colors.other.primary; + + // 如果需要创建阴影滤镜 + if (variables.has_shadow) { + const filter = defs.append("filter") + .attr("id", "shadow") + .attr("filterUnits", "userSpaceOnUse") + .attr("width", "200%") + .attr("height", "200%"); + + filter.append("feGaussianBlur") + .attr("in", "SourceAlpha") + .attr("stdDeviation", 3); + + filter.append("feOffset") + .attr("dx", 2) + .attr("dy", 2) + .attr("result", "offsetblur"); + + const feMerge = filter.append("feMerge"); + feMerge.append("feMergeNode"); + feMerge.append("feMergeNode").attr("in", "SourceGraphic"); + } + + // 如果需要创建渐变 + if (variables.has_gradient) { + sortedData.forEach((item, idx) => { + // 添加安全的ID处理 + const safeCategory = typeof item.x === 'string' ? + item.x.toString().replace(/[^a-zA-Z0-9]/g, '-').toLowerCase() : + `category-${idx}`; + + const baseColor = getColor(); + const gradientId = `gradient-${safeCategory}`; + + const gradient = defs.append("linearGradient") + .attr("id", gradientId) + .attr("x1", "0%") + .attr("y1", "100%") + .attr("x2", "0%") + .attr("y2", "0%"); + + gradient.append("stop") + .attr("offset", "0%") + .attr("stop-color", d3.rgb(baseColor).darker(0.1)); + + gradient.append("stop") + .attr("offset", "100%") + .attr("stop-color", d3.rgb(baseColor).brighter(0.1)); + }); + } + + // ---------- 7. 创建图表 ---------- + + // 创建图表组 + const chart = svg.append("g") + .attr("transform", `translate(${margin.left}, ${margin.top})`); + + // 创建比例尺 + const xScale = d3.scaleBand() + .domain(sortedData.map(d => d.x)) + .range([0, innerWidth]) + .padding(variables.has_spacing ? 0.4 : 0.2); + + const yMax = d3.max(sortedData, d => d.y); + const yScale = d3.scaleLinear() + .domain([0, yMax > 0 ? yMax * 1.1 : 1]) // 处理y都为0的情况，并添加10%的填充 + .range([innerHeight, 0]); + + // ******************************************************************* + // ** 开始修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + const defaultLabelFontSize = parseFloat(typography.label.font_size || 12); + const minLabelFontSize = 10; // 最小字体大小 + const currentBarWidth = xScale.bandwidth(); // 使用实际的bar宽度 + let finalLabelFontSize = defaultLabelFontSize; + let maxLinesNeeded = 1; // 记录所有标签所需的最大行数 + const labelFontFamily = typography.label.font_family || "Arial"; + const labelFontWeight = typography.label.font_weight || "normal"; + const lineHeightFactor = 1.2; // 行高倍数 + + // 文本宽度测量辅助函数 (使用 canvas 提高性能) + const canvas = document.createElement('canvas'); + const ctx = canvas.getContext('2d'); + function getTextWidthCanvas(text, fontFamily, fontSize, fontWeight) { + ctx.font = `${fontWeight || 'normal'} ${fontSize}px ${fontFamily || 'Arial'}`; + return ctx.measureText(text).width; + } + + // 第一遍计算：确定统一的字体大小 + if (currentBarWidth > 0) { // 确保 barWidth 有效 + let maxRatio = 1; + sortedData.forEach(d => { + const labelText = String(d.x); // 确保是字符串 + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, defaultLabelFontSize, labelFontWeight); + const ratio = textWidth / currentBarWidth; + if (ratio > maxRatio) { + maxRatio = ratio; + } + }); + + if (maxRatio > 1) { + finalLabelFontSize = Math.max(minLabelFontSize, Math.floor(defaultLabelFontSize / maxRatio)); + } + + // 第二遍计算：确定是否需要换行以及最大行数 (使用最终字体大小) + sortedData.forEach(d => { + const labelText = String(d.x); + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + + if (textWidth > currentBarWidth) { + // 模拟换行计算行数 + const words = labelText.split(/\s+/); // 按空格分词 + let currentLine = ''; + let lines = 1; + let simulationSuccess = false; // 标记模拟是否成功 + + if (words.length > 1) { // 优先按单词换行 + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > currentBarWidth && currentLine !== '') { + lines++; + currentLine = words[i]; + // 检查单个单词是否也超长 + if (getTextWidthCanvas(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth) { + // 单个单词超长，需要转字符换行 + simulationSuccess = false; + break; // 退出单词循环 + } + } else { + currentLine = testLine; + } + } + if(currentLine !== '') simulationSuccess = true; // 如果有剩余单词则标记成功 + + } + + // 如果单词换行不成功或只有一个单词，尝试字符换行 + if(words.length <= 1 || !simulationSuccess) { + lines = 1; // 重置行数 + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > currentBarWidth && currentLine !== '') { + lines++; + currentLine = chars[i]; + } else { + currentLine += chars[i]; + } + } + } + + + if (lines > maxLinesNeeded) { + maxLinesNeeded = lines; + } + } + }); + } else { + // 如果barWidth无效，则使用默认字体大小且不换行 + finalLabelFontSize = defaultLabelFontSize; + maxLinesNeeded = 1; + } + // ******************************************************************* + // ** 结束修改：预计算标签字体大小和最大行数 ** + // ******************************************************************* + + // ******************************************************************* + // ** 开始修改：计算图标的统一Y位置 ** + // ******************************************************************* + const labelStartY = innerHeight + 35; // 标签开始的 Y 位置 (保持和原来一致) + const lineHeight = finalLabelFontSize * lineHeightFactor; // 行高 + const labelBottomApprox = labelStartY + (maxLinesNeeded - 1) * lineHeight + finalLabelFontSize * 0.71; // 估算最下方标签基线位置 + const iconRadius = 15; // 图标半径 + const iconYPosition = labelBottomApprox + iconRadius + 5; // 在标签下方留出 5px 间距放置图标中心 + const iconBottomY = iconYPosition + iconRadius; // 图标底部的Y坐标 + const barExtensionBuffer = 5; // 柱子比图标底部多延伸的距离 + const barBottomY = iconBottomY + barExtensionBuffer; // 柱子需要延伸到的最终Y坐标 + // ******************************************************************* + // ** 结束修改：计算图标的统一Y位置 ** + // ******************************************************************* + + // 添加延伸到图标的柱子 + chart.selectAll(".bar") + .data(sortedData) + .enter() + .append("image") + .attr("class", "bar") + .attr("x", d => xScale(d.x)) + .attr("y", d => yScale(d.y)) + .attr("width", xScale.bandwidth()) + .attr("height", d => Math.max(0, barBottomY - yScale(d.y))) + .attr("xlink:href", d => d.icon) + .attr("preserveAspectRatio", "none") + + // 在柱子上方添加数值标签 + const defaultAnnotationFontSize = parseFloat(typography.annotation.font_size || 12); + const minAnnotationFontSize = 6; // 数值标签最小字体 + const annotationFontFamily = typography.annotation.font_family || "Arial"; + const annotationFontWeight = typography.annotation.font_weight || "bold"; + + chart.selectAll(".value-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "value-label") + .attr("x", d => xScale(d.x) + xScale.bandwidth() / 2) + .attr("y", d => yScale(d.y) - 5) + .attr("text-anchor", "middle") + .style("font-family", annotationFontFamily) + .style("font-weight", annotationFontWeight) + .style("fill", colors.text_color || "#333333") + .each(function(d) { + const valueText = (typeof d.y === 'number' ? d.y.toFixed(1) : String(d.y)) + (yUnit || ""); + const maxWidth = xScale.bandwidth() * 1.1; // 最大允许宽度为柱宽的1.1倍 + let finalValueFontSize = defaultAnnotationFontSize; + + if (maxWidth > 0) { // 仅当宽度有效时计算 + const textWidth = getTextWidthCanvas(valueText, annotationFontFamily, defaultAnnotationFontSize, annotationFontWeight); + if (textWidth > maxWidth) { + finalValueFontSize = Math.max(minAnnotationFontSize, Math.floor(defaultAnnotationFontSize * (maxWidth / textWidth))); + } + } + + d3.select(this) + .style("font-size", `${finalValueFontSize}px`) + .text(valueText); + }); + + // 在维度标签上方添加水平线 + chart.append("line") + .attr("x1", 0) + .attr("y1", innerHeight + 20) // 直接位于维度标签上方的位置 + .attr("x2", innerWidth) + .attr("y2", innerHeight + 20) + .attr("stroke", "#e0e0e0") + .attr("stroke-width", 1); + + // ******************************************************************* + // ** 开始修改：添加维度标签 (统一字体大小，自动换行) ** + // ******************************************************************* + chart.selectAll(".dimension-label") + .data(sortedData) + .enter() + .append("text") + .attr("class", "dimension-label") + .attr("text-anchor", "middle") + .style("font-family", labelFontFamily) + .style("font-size", `${finalLabelFontSize}px`) // 应用预计算的字体大小 + .style("font-weight", labelFontWeight) + .style("fill", "#ffffff") // 使用默认文本颜色 + .each(function(d) { + const labelText = String(d.x); + const textWidth = getTextWidthCanvas(labelText, labelFontFamily, finalLabelFontSize, labelFontWeight); + const textElement = d3.select(this); + const xPos = xScale(d.x) + xScale.bandwidth() / 2; + const availableWidth = xScale.bandwidth(); + + if (textWidth > availableWidth && availableWidth > 0) { + // 需要换行 (重复之前的换行逻辑来渲染) + const words = labelText.split(/\s+/); + let lines = []; + let currentLine = ''; + let simulationSuccess = false; + + if(words.length > 1){ + for (let i = 0; i < words.length; i++) { + const testLine = currentLine ? currentLine + " " + words[i] : words[i]; + const testWidth = getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight); + if (testWidth > availableWidth && currentLine !== '') { + lines.push(currentLine); + currentLine = words[i]; + if (getTextWidthCanvas(currentLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth) { + simulationSuccess = false; break; + } + } else { currentLine = testLine; } + } + if(currentLine !== '') { lines.push(currentLine); simulationSuccess = true; } + } + if(words.length <= 1 || !simulationSuccess) { + lines = []; + const chars = labelText.split(''); + currentLine = ''; + for (let i = 0; i < chars.length; i++) { + const testLine = currentLine + chars[i]; + if (getTextWidthCanvas(testLine, labelFontFamily, finalLabelFontSize, labelFontWeight) > availableWidth && currentLine !== '') { + lines.push(currentLine); currentLine = chars[i]; + } else { currentLine += chars[i]; } + } + lines.push(currentLine); + } + + lines.forEach((line, i) => { + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY + i * lineHeight) + .attr("dy", "0.71em") + .text(line); + }); + } else { + // 不需要换行 + textElement.append("tspan") + .attr("x", xPos) + .attr("y", labelStartY) + .attr("dy", "0.71em") + .text(labelText); + } + }); + // ******************************************************************* + // ** 结束修改：添加维度标签 ** + // ******************************************************************* + + + // ******************************************************************* + // ** 开始修改：添加圆形图标 - 动态调整 Y 位置 ** + // ******************************************************************* + chart.selectAll(".icon-circle") + .data(sortedData) + .enter() + .append("g") + .attr("class", "icon-circle") + .attr("transform", d => `translate(${xScale(d.x) + xScale.bandwidth() / 2}, ${iconYPosition})`) // 应用动态Y位置 + .each(function(d) { + // 添加圆形轮廓 + d3.select(this) + .append("circle") + .attr("r", iconRadius) // 使用变量 + .attr("fill", "none") // 无填充 + .attr("stroke", "#2D3748") // 更深灰色的描边 + .attr("stroke-width", 0.1); + + // 如果有该类别的图像 + if (images && images.field && images.field[d.x]) { + d3.select(this) + .append("image") + .attr("xlink:href", images.field[d.x]) + .attr("x", -12) + .attr("y", -12) + .attr("width", 24) + .attr("preserveAspectRatio","xMidYMid meet") + .attr("height", 24); + } + }); + // ******************************************************************* + // ** 结束修改：添加圆形图标 ** + // ******************************************************************* + + + // 返回SVG节点 + return svg.node(); +} \ No newline at end of file