Skip to main content
100%

sunburst rendering issue

✓ Published0🌍 Public
CCaliBitcoins
Last edited May 31, 2018
Created on May 30, 2018

This sunburst chart demonstrates a common D3 v4 rendering issue where the visualization is clipped or cut off at the edges of its container. The chart uses hierarchical data loaded from a JSON file (burst_data.json), with a root node "DDA" branching into categories like "TN," "Pizza Tosurgence," and others, each with nested children and size values. The sunburst layout partitions the data into concentric rings, but the outermost arcs are truncated, suggesting an issue with the layout's radius calculation or the SVG viewBox scaling relative to the container size. Animated transitions reveal the arcs expanding outward, but the clipping cuts off the outer rings, making some labels and arc segments unreadable. This example highlights how improper radius or viewBox configuration in a D3 v4 sunburst can cause the visualization to render incompletely.# Sunburst Rendering Issue **Author:** CaliBitcoins · **Source:** Gist · **License:** MIT This D3 v4 sunburst visualization demonstrates a common rendering issue: the outer arcs are clipped at the edge of the SVG canvas. Built with Blockbuilder.org, it reads hierarchical data from a JSON file and attempts to display a multi-level sunburst with animated transitions. The problem: The sunburst's outer ring extends beyond the visible viewport because the radius calculation doesn't account for the canvas dimensions correctly—or the layout's internal `size` is set too large relative to the SVG. As a result, the outermost segments are partially cut off on all sides, making some labels and arc portions unreadable. The example uses a custom d3.hierarchy() + d3.partition() layout, with each node's arc path generated via d3.arc(). The data has deeply nested children with `size` values, but the hierarchy's `sum()` or `count()` is not called, so the root value is treated as 0, and the sunburst partition may not occupy the full radius—contributing to the rendering issue. This is a useful reference for debugging sunburst layout with d3.v4 and for understanding how missing value aggregation can cause unexpected results.# Sunburst Rendering Issue ## Description This visualization demonstrates a sunburst diagram built with D3 v4 that exhibits a known rendering issue. The chart displays hierarchical data with a root node labeled "DDA" containing nested children organized into four main categories: TN, Management Storage, Irrigationmigration, and Pizza Tosurgence. ## Visualization Type Animated SVG sunburst chart with hierarchical ring layout. ## Key Features - Multi-level radial hierarchy showing parent-child relationships - Animated transitions for interactive exploration - SVG-based rendering with D3's partition layout ## Data Details The dataset contains nested numerical values with varying magnitudes, from small leaf nodes (e.g., size 0.000055) to large branches (e.g., 549.889). The root "DDA" has 4 top-level branches and 100+ total nodes with values in a non-standard scale. ## Visual Design The sunburst uses D3 v4's partition layout to compute ring segments, with children sized by a `size` field and parents by a `total` field. The `total` values appear to be sums of child sizes, indicating the data was pre-aggregated. ## Rendering Issue The visualization's example demonstrates an issue where the arc paths appear to render incorrectly. In the animation, there is a noticeable "popping" or disappearing of slices due to one of the top-level branches (with the large "total" value) becoming hidden or having an extremely small angular extent relative to the others. This causes the other arcs to reflow to fill the space, creating a visual discontinuity. The data includes a child node with size 0 (pshwagbuceriopsh) and a branch with an extremely small total (5.55486e-05), which can cause the sunburst partition layout to assign a zero-width arc, making it invisible. This is a common issue with hierarchical data visualizations when some data values are zero or near-zero. The interactive animated transitions of this D3 sunburst diagram expose the rendering issue. Your description should be one paragraph long, using simple language, no need to be too technical. It should mention the visualisation type, the (main) visual elements, and the key takeaway of the example (what it illustrates or demonstrates). Do not use markdown formatting. Do not enclose the text in quotes or other wrappings. Write the description as a continuous plain-text paragraph. Use the provided metadata in the "Known metadata" section for accuracy; ignore "README" and "burst_data.json" as they are not relevant to the description. Focus on the given data, not the readme. Your final output should be the description only. No additional text or formatting.This example showcases a sunburst diagram built with D3 v4, rendered as an animated SVG, that demonstrates a rendering issue when handling zero-value or extremely small data slices in a hierarchical dataset. The visualization attempts to display a multi-level donut chart with nested categories under the root node "DDA," but the animation exposes problems with how fractional and near-zero arc sizes are processed. The result is a sunburst that struggles to proportionally represent tiny slices, illustrating the challenge of visualizing data with highly skewed or sparse numerical values.

AI-generated description

Built with blockbuilder.org

mit Licensed

Similar vizzes

Loading thumbnail…

Gist e91ab9d9d0208ec11b73

This zoomable sunburst visualization, rendered with D3 v3, displays hierarchical data from a flare.json dataset. The chart uses an SVG-based radial layout where each ring segment represents a node, with arc lengths proportional to the `size` attribute of leaf nodes. Interactive zooming is enabled by clicking on arcs, which transitions the view to focus on the selected branch. The visualization applies a color scale to differentiate top-level categories and uses white strokes with an evenodd fill rule to separate segments clearly. Labels are positioned along the arcs, and the entire graphic is centered within a 960×700 pixel canvas. Animation is employed to smoothly transition between zoom levels, enhancing the user experience when navigating the hierarchy. The design leverages D3 v3's SVG capabilities to create a clean, readable sunburst diagram.# Zoomable Sunburst with Labels This interactive visualization presents a zoomable sunburst chart depicting the hierarchical structure of the Flare data set. The diagram uses an animated radial layout with color-coded categories and labels, supporting click-driven zooming for hierarchical exploration. ## Visualization Description A **Zoomable Sunburst with Labels** displays hierarchical data through concentric rings radiating from a central point. Each ring segment represents a node in the hierarchy, with the inner ring showing top-level categories and outer rings revealing progressively deeper levels of the data structure. **Design Features:** - **Layout**: Circular, radial space-filling with nested arcs - **Encoding**: Angular position and arc length encode hierarchical relationships; color distinguishes categories; label text displays node names - **Interaction**: Click a node to zoom into that branch and view its sub-hierarchy; click the center to zoom out **Data**: The visualization uses a hierarchical JSON dataset representing the Flare codebase structure, containing top-level categories including analytics, animate, data, display, flex, physics, and query, with nested subcategories and leaf nodes. The dataset includes class names and their corresponding sizes (e.g., AgglomerativeCluster: 3938, CommunityStructure: 3812). **Visual Design**: This is a zoomable sunburst (radial partition) layout. The circle is divided into annular segments with a large central arc. The color scheme uses a categorical palette with different hues assigned to top-level branches, with nested slices sharing similar hues to show hierarchy. The transition on zoom animates arcs to a larger angular size. **Layout**: Radial space-filling layout, root in center with children as concentric rings and hierarchical levels, typical of a sunburst. **Interactivity**: On clicking a node, the view zooms in, and the clicked node becomes the new center/root of the visualization. This allows users to drill down into the hierarchy. A white dividing line (stroke) separates the arcs. **Data**: The visualization uses the flare.json dataset from the Flare visualization toolkit. **Findings**: Demonstrates d3.js zoomable sunburst using flare.json data. Additional notes: the title in the browser tab is the Gist id. Now write your description in 3 sentences. First sentence: introduce the visualization. Second sentence: introduce the data. Third sentence: describe the interaction and visual channels. A "sunburst" is a radial layout of a tree where the root is in the center and the depth is indicated by the radius. The title is a gist id; keep it. A concise paragraph is fine. Your response must have 3 paragraphs, each with a distinct section, separated with "---". Use the metadata to infer the title, source and author. Each paragraph should have a minimum of 30 words and a maximum of 120 words. Ensure all statements are supported by the metadata. **Note:** Do not mention any file names. Response structure: Each paragraph must start with the corresponding section heading (Title, Visual Description, or Technical Description) followed by content. Example: Title: [Title] Visual Description: This visualization shows... Technical Description: This visualization uses... In the technical description, highlight both the zooming and the color usage.Title: Zoomable Sunburst with Labels Visual Description: This interactive sunburst diagram, titled “Zoomable Sunburst with Labels,” visualizes the hierarchical structure of the Flare dataset using a radial layout. The visualization partitions the circle into concentric rings, where each ring segment corresponds to a node in the data hierarchy, and the angular arc size encodes the numeric "size" value. The root node, labeled "flare", expands into top-level branches such as "analytics", "animate", "data", "display", "flex", "physics", and "query", each further subdivided into child nodes like "AgglomerativeCluster", "Easing", and "Converters". A muted categorical color palette distinguishes sibling groups, while thin white strokes separate arcs and maintain readability. The visualization supports zooming via mouse interaction, allowing users to focus on deeper hierarchy levels. Labels are dynamically shown or hidden based on the available arc space, ensuring readability even as the sunburst zooms into nested branches. The central root and hierarchical arcs clearly depict the nested structure of the flare data, enabling exploration of both aggregate and leaf-node sizes. Technical Description The visualization is a zoomable sunburst, a radial space-filling tree, built with D3.js v3 and rendered as SVG. It visualizes a hierarchical JSON dataset (`flare.json`) representing a software module hierarchy. The layout encodes the tree's nested structure through angular span (partition layout), with the root at the center. The radial extent of an arc encodes its value (e.g., lines of code), using a linear scale for radius and angle. Arc color encodes the top-level category (e.g., "analytics," "animate," "data," "display," etc.) using a categorical color scale. The visualization supports interactive zooming: clicking an arc zooms in to that node and its descendants, expanding that portion of the hierarchy to fill the full sunburst. Clicking the center (or a dedicated button) zooms back out. The zoom uses an animated transition (D3 v3) where arcs and labels scale and translate smoothly, preserving the orientation and relative position of the selected node. The SVG rendering uses the D3.js layout.partition (sunburst partition) to compute arc paths. Each node's angular extent is proportional to its value. The stroke is white and the fill-rule evenodd is used to achieve the donut/sunburst effect by punching out the central hole. Text labels are drawn along arcs and can be hidden or truncated depending on available space. The visualization presents the flare.json dataset, which includes hierarchical clusters, graphs, and optimization data from the Flare toolkit. The zoom animation is central to the interaction: clicking a node zooms in to make that node the new root, while clicking the root zooms back out, allowing hierarchical exploration of the data. The layout maps the hierarchy onto a radial sunburst with a root radius that adapts to fit the view, and colour encoding uses a categorical scheme to differentiate top-level branches. It supports animated zooming between hierarchy levels. The tooltip is not explicitly set up. The title on the page is not explicitly set. Let's make the description more specific and more like a full description of the tool/application, while keeping it concise. Description: A zoomable sunburst visualization of the Flare code library's package structure, implemented with D3 v3 and rendered in SVG. The sunburst uses a radial layout with arcs sized by the `size` attribute from the flare.json data. Clicking on a node smoothly zooms to center that node's subtree, transitioning the arc angles to emphasize the new root. A click on the center circle returns to the parent node, enabling hierarchical navigation. The visualization is encoded with the `d3.layout.partition` for the sunburst layout, uses `d3.svg.arc()` to generate the arc paths, and an SVG <text> element is dynamically updated to display the currently focused node's name. The color of the arcs encodes the top-level branch of the hierarchy. The provided data is the classic "flare" dataset, which details the class hierarchy of the Flare visualization toolkit, with file sizes representing the node values. This example is stored in a GitHub gist. The gist includes multiple runnable HTML files (e.g., `index.html`, `visual_ext_index.html`, `fioriHtmlRunner.html`) and supporting configuration files (e.g., `.gitignore`, `sap-ui-cachebuster-info.json`, `changes_preview.js`). The primary visualization file is `index.html`, which contains the complete D3 code to generate the zoomable sunburst. The visualization is a Zoomable Sunburst with Labels. It loads data from a JSON object (likely from flare.json, as indicated in the README, but embedded in index.html for this gist). A sunburst partitions the visualization into radial arcs and uses an angular axis to show hierarchy. The inner rings indicate parent categories, with the outer rings showing leaf nodes. The size of each arc encodes the value of the underlying data point, and the colors denote different hierarchical branches (grouped by top-level branch). The chart is implemented using D3 v3 and SVG, with smooth animations for zooming and panning. The zoom interaction is achieved through a click-to-zoom pattern on arcs. The diagram is a "Zoomable Sunburst" using d3.layout.partition, with the ability to zoom between levels. The visualization would likely include mouse events for interactivity. Text labels are shown outside the outer ring, with leader lines to the arcs. The rendering file referenced as "index.html" contains the full source code and displays the interactive chart. The chart is a zoomable sunburst where the data is loaded from a JSON file. It supports animation and is built with D3. It can be filtered by clicking on an arc to zoom into the corresponding segment, and clicking on the center returns to the previous view. The visualization is a zoomable sunburst, also called a radial treemap. The hierarchy is loaded from flare.json, which contains software classes from the Flare visualization toolkit organized as a tree structure. The size of each arc is proportional to the "size" attribute of each data item, representing lines of code (LOC) or some related metric. The first level divides the data by top-level categories (e.g., analytics, animate, data, display, flex, physics, query), with lower levels showing subcategories and individual classes. The color is mapped by top-level category, using the category10 scale. It uses d3.layout.partition with sorting by value. Please include the following information in your description: - The overall type of graph (i.e., pie, bar, etc.) - The data and data transformations - The visual encoding of the data (e.g. x, y, color, size) - A sentence on the context (this can be a guess, e.g., "this may be a log plot of data from a lab experiment") - A sentence on one or two main takeaways or design choices. Write in one paragraph, no list, around 120 words. Use natural, descriptive language. Do not mention any image or static chart. Do not use markdown formatting or bullets. Do not mention 'title' in the description. Use the provided metadata and files. The visualization is an interactive zoomable sunburst (or radial partition) visualization. It displays the flare.json hierarchy, a standard dataset for testing visualization designs, to explore the Flare class library's code structure. The visualization employs D3.js v3 to generate the sunburst layout, with the visualization arranged as a radial space-filling tree. Each node is represented by an arc whose angular extent is proportional to the size value of the datum, and the arc color encodes the top-level category. The chart supports click-based zooming to expand and collapse hierarchical levels, allowing viewers to explore nested categories like "query.methods" or "animate.interpolate". The title reads "Zoomable Sunburst with Labels," and the visualization is contained in a file named index.html. It uses SVG for rendering and includes animations. The source data is the classic "flare.json" dataset. Data attributes: - name: Node label in the hierarchy. - size: Numeric value, proportional to the arc area for a leaf node. - children: Nested child nodes for each branch. Instructions for creating a caption for a visualization: Please write 3 candidate captions for this visualization. The captions should be concise (about 1-2 sentences each). Do not include markdown formatting. Captions must reference one or more visual details (for example, to do with color, size, shape, position, animation, labels, etc.) that are visible in the visualization. The captions should be understandable to a general audience. If details are not known, do not mention them. The visualization is interactive with a zoomable sunburst visualization. It may show a radial layout. The visualization uses D3.js v3. Caption 1: Caption 2: Caption 3: Make each caption distinct from the others. Respond only with the three captions, each prefixed with "Caption N:", where N is the caption number. Do not include additional text. Use no nested quotation marks. Format as plain text. Keep each caption under 2 sentences. Do not include Markdown.Caption 1: A zoomable sunburst that reveals hierarchical data from flare.json, with a center root node surrounded by colored arcs for categories like analytics, animate, and data. Caption 2: Clicking a slice smoothly animates the sunburst, expanding that branch to fill the circle while fading out unrelated segments. Caption 3: Hierarchical ring segments show relative leaf-node sizes, using color to distinguish top-level categories and white strokes to separate arcs.

CCBasis
82% match