D

Difan Gu

@difangu·21 public vizzes

Loading thumbnail…

Cars Scatter Plot

This scatter plot visualizes the relationship between horsepower and weight for a collection of cars, with each point representing an individual vehicle. Using a red, semi-transparent circle for each data point, the chart reveals the overall correlation between these two vehicle attributes. Built with D3 v5, the visualization renders as an SVG and loads data from a CSV file. The example demonstrates the use of D3's `scaleLinear` for axis mapping, `axisLeft` and `axisBottom` for generating the plot's axes, and the `csv` function for data ingestion.

Loading thumbnail…

Let's make a face with D3.js!

This example shows a smiley face built from SVG shapes, with eyebrows that animate in response to the viewer’s actions. The code demonstrates fundamental DOM manipulation with D3.js v5, using `d3.select` and `d3.append` to create the face’s elements. It relies on the `d3.arc` generator for the mouth and applies simple transitions to move the eyebrows. The page reads the client’s viewport dimensions to size the SVG canvas, and styling is handled via an external stylesheet.

Loading thumbnail…

Let's make a face with D3.js!

A smiling face is drawn on an SVG canvas using D3.js, with eyebrows that move dynamically to create an animated expression. The example demonstrates fundamental DOM manipulation by selecting the SVG element via `d3.select`, reading its width and height attributes, and using D3's `arc` function to construct the facial features. The rendering is entirely vector-based, relying on SVG shapes styled through an external stylesheet. The interaction and motion are driven by D3's data-binding and attribute-update capabilities, highlighting the library's core strengths in programmatic visualization and animation.

Loading thumbnail…

Let's make a face with D3.js!

This example visualizes the world map as a set of orange countries on a steel-blue spherical background, with hover states that turn a country red. The shape data comes from the world-atlas TopoJSON and TSV files, which are joined to label each country with its name. The visualization uses the D3.js `geoPath` and `geoNaturalEarth1` projection to render the map, and the topojson `feature` function to convert TopoJSON topology into GeoJSON features. A zoom interaction is enabled through D3’s `zoom` event, which transforms the map group.

Loading thumbnail…

Let's make a face with D3.js!

This example displays a natural Earth projection of the world map, with countries rendered as orange paths on a steel-blue sphere. It uses D3.js v5’s `geoNaturalEarth1` and `geoPath` to generate the geographic outlines, while TopoJSON’s `feature` extracts country boundaries from the world-atlas dataset. The SVG paths are appended asynchronously after fetching the 110m resolution TopoJSON file. A black stroke with low opacity outlines each country, and the page sets no margins to let the visualization fill the entire viewport.

Loading thumbnail…

Let's make a face with D3.js!

This example uses D3.js to project world countries onto a natural Earth projection, rendering them as orange SVG paths with a steel-blue sphere background. It loads GeoJSON data from the world-atlas TopoJSON file via `d3.json` and converts it with `topojson.feature`. The visualization then applies `d3.geoPath` with `geoNaturalEarth1` to draw each country, highlighting the geographic layout without interactive features.

Loading thumbnail…

Bowl of Fruit - General Update Pattern Special Cases

This example demonstrates the general update pattern in D3, showing how SVG elements are added, removed, and modified over time. A bowl of fruit, rendered as red apples and yellow lemons, changes as a timer triggers actions: five apples appear, one is removed, an apple transforms into a lemon, and another apple is deleted. The implementation uses D3's `select`, `merge`, and `exit` operations to handle entering and exiting elements, with `scaleOrdinal` mapping fruit types to circle radii and colors.

Loading thumbnail…

Let's make a face with D3.js!

This example shows a fruit bowl visualization where apples and lemons are rendered as colored circles, with a face-like arrangement created through D3.js data joins. The code uses `d3.select`, `d3.range`, and `d3.scaleOrdinal` to map fruit types to red and yellow colors and different radii. It demonstrates enter, update, and exit selections, first removing an apple, then replacing one with a lemon via `setTimeout`. The SVG output is generated from a simple `fruitBowl` function that binds fruit data to circles.

Loading thumbnail…

Bowl of Fruit - General Update Pattern Special Cases

This example demonstrates special cases of D3’s general update pattern for animated transitions in SVG. It shows a bowl of fruit where apples are initially added, then removed, one apple is replaced with a lemon, and another apple is deleted, with each change re-rendering the scene. The code uses `d3.select` and `d3.range` to manage the data, while custom functions `groupsEnter.merge(groups)` and `groups.exit().remove()` handle enter, update, and exit states. Ordinal scales (`scaleOrdinal`) map fruit types to radii and fill colors, with `rect` and `circle` elements drawn via SVG attributes.

Loading thumbnail…

Scatterplot

This scatterplot visualizes world population over time as an area chart. The x-axis maps time using `d3.scaleTime`, while the y-axis uses `d3.scaleLinear` for population values, with gridlines and red axis labels. The code loads a CSV dataset via `d3.csv`, converts the population to numbers and year to dates, then renders the area path using `d3.area` and `curveBasis`. Axes are drawn with `d3.axisBottom` and `d3.axisLeft`, with tick styling and a title, all output as SVG.

Loading thumbnail…

Scatterplot

This scatterplot visualizes temperature changes over time in San Francisco, using a filled area chart to emphasize the temperature range. The SVG rendering employs D3 v5’s `scaleTime` and `scaleLinear` for axes, `area` generator with `curveBasis` for smooth lines, and `axisLeft`/`axisBottom` with tick marks. Styled circles and a steelblue path highlight the data, while custom margins and labels (like “Temperature” and “Time”) frame the chart. Data is loaded as CSV from a VizHub dataset, parsed into numbers and dates, and mapped to the scales.

Loading thumbnail…

Scatterplot

This scatterplot displays the top 10 most populous countries, mapping each nation’s population on the x-axis against its name on the y-axis. It uses D3 v5 with SVG rendering, employing `scaleLinear` and `scalePoint` for axes, `axisLeft` and `axisBottom` for ticks, and `format(".3s")` to abbreviate large numbers. The data comes from an external CSV file.

Loading thumbnail…

Scatterplot

A scatterplot displays the population of the ten most populous countries, with population on the x-axis and country names on the y-axis. The visualization uses a linear scale for population and a point scale for countries. The code loads data from a CSV file, parses population values, and renders circles using D3 v5's selection methods. It includes axis labels, a chart title, and gridlines generated with `axisBottom` and `axisLeft`, with an SVG rendering approach.

Loading thumbnail…

Let's make a face with D3.js!

This example visualizes the top 10 most populous countries as a horizontal bar chart. The chart displays population values on the x-axis and country names on the y-axis, with a red axis label and a title. The code uses D3.js v5 with `scaleLinear`, `scaleBand`, `axisLeft`, and `axisBottom` to construct the chart. Data is loaded from a CSV file via `d3.csv`, and population values are multiplied by 1000. Bars are rendered as SVG rectangles with a steelblue fill, and x-axis tick labels are formatted using the `format(".3s")` function, replacing "G" with "B".

Loading thumbnail…

Let's make a smiley face with D3.js

This example creates a smiley face from basic SVG shapes using D3.js, drawn on a 960×500 canvas. The face consists of a yellow circle with a black stroke, two eyes, rectangular eyebrows, and a mouth created with D3’s `arc` function. The eyebrows animate by chaining two `transition().duration(2000)` calls, moving them down and then back up over four seconds. The code uses D3 v5 selections (`select`, `append`) and attribute setters to position elements via transforms.

Loading thumbnail…

Let's make a face with D3.js!

This example displays a horizontal bar chart of country populations using D3.js v5, with each bar’s length scaled linearly against population values and countries ordered along a band scale. The SVG rendering relies on `d3.scaleLinear`, `d3.scaleBand`, `d3.axisLeft`, and `d3.axisBottom` to compose axes, while data loads from a CSV file via `d3.csv` and populates `rect` elements dynamically.

Loading thumbnail…

Let's make a face with D3.js!

A yellow circle with two black eyes, animated eyebrows, and an arc-shaped mouth forms a smiling face. The example demonstrates basic D3.js v5 shape generation and SVG manipulation, using `d3.select` to append circles, rectangles, and a path built with `d3.arc`. The eyebrows move up and down via chained `transition().duration()` calls, creating a subtle animated expression. All elements are centered within an SVG of fixed dimensions using a translated group.

Loading thumbnail…

Shapes with SVG and CSS

This example shows a collection of basic SVG shapes, including circles, rectangles, lines, and a path, arranged in a coordinate system and scaled up. The shapes have various fills, strokes, and stroke widths, with some styles inherited from a parent group or defined via CSS classes. It uses raw SVG elements such as `circle`, `rect`, `line`, and `path`, with transformations like `scale` and `translate`. The rendering approach uses an inline SVG, with styling applied through an external CSS stylesheet that defines classes like `.lines` for stroke properties.

Loading thumbnail…

Smiley Face Part IV

A React component renders a yellow smiley face as a scalable vector graphic using D3’s `arc` generator to shape the mouth. D3’s `arc` function defines the mouth’s inner and outer radii, start and end angles, while SVG circle elements compose the head and eyes. The code imports a smile.svg image into a header, though the main visualization uses only D3 shapes. The React app mounts to the DOM, positioning all elements at fixed coordinates within an SVG canvas.

Loading thumbnail…

Hello VizHub

This example demonstrates VizHub’s ability to render a simple text message defined in a separate data module. The code uses the D3 v5 library solely for loading, while the core interaction is a plain JavaScript DOM selection via `document.getElementById`. The message originates as the string "hello" in `cars.js`, is imported and assigned in `index.js`, and then displayed inside a styled HTML element. The visualization is static, with no dynamic data or scales, highlighting fundamental module import and DOM manipulation.

Loading thumbnail…

Cars Report

This example renders a minimal React-based page titled “Cars Report.” The code defines a single constant, `message`, set to “Hello World,” but does not yet display it. The visualization uses React as its framework, with the page loading a bundled JavaScript file via a standard HTML entry point. No data sources or rendering APIs are employed beyond the basic React setup and HTML script tag, leaving the visualization behavior entirely unimplemented.