John Lewis

Missing Migrants on a map v2

This visualization combines a world map and a time-series histogram to show the locations and monthly counts of dead and missing migrants in 2019. The map uses `d3.geoNaturalEarth1` projection and `d3.geoPath` to render country outlines, graticules, and sphere, with semi-transparent circles scaled by `d3.scaleSqrt` based on the total dead and missing per incident. A linked histogram below, built with `d3.bin` and `d3.timeMonths`, aggregates the same data over time. The code uses React and D3 v7 with data loaded via `d3.csv` and TopoJSON world atlas from unpkg.

Nov 6, 2021

Multiple Views with Brushing

This visualization combines a bubble map of global migrant deaths with a brushing-linked time series histogram. The map uses D3’s `geoNaturalEarth1` projection and `geoPath` to render country boundaries and proportional circles sized by death counts. Selecting a date range with `brushX` on the histogram filters the map’s data in real time. The React app loads CSV data from Simplemaps and TopoJSON world atlas boundaries, rendering both views as SVG.

Nov 6, 2021

Fork of Fork of Migrant Deaths x3

This histogram visualizes the monthly totals of dead and missing migrants from a subset of the Missing Migrants Global dataset. React renders the SVG, while D3 v7 handles data loading, time-based binning with `timeMonths`, and linear scaling. The chart uses two custom axis components and rectangular marks to display aggregated counts over time, with the y-axis formatted in compact notation.

Missing Migrants on a map

This map uses a natural Earth projection to display global incidents of missing migrants as semi-transparent circles sized by the total dead and missing count. The visualization layers country boundaries, graticules, and a sphere outline using `d3.geoPath` and `geoNaturalEarth1`. Circle radii are scaled with `d3.scaleSqrt` based on the CSV’s “Total Dead and Missing” column. The React app loads world atlas TopoJSON via topojson’s `feature` and `mesh`, then renders all elements as SVG. The minimalist, muted color palette (blue-gray ocean, gray land, teal markers) prioritizes the spatial distribution of incidents.

Fork of Migrant Deaths x2

This visualization displays monthly totals of dead and missing migrants over time using a bar chart. A time-series histogram is computed by binning reported dates into months using `d3.histogram` and `d3.timeMonths`, with the y-axis representing summed casualty counts. The chart is rendered as an SVG using React and D3 v7, with scales created via `d3.scaleTime` and `d3.scaleLinear`, and axes drawn by custom React components. Data is loaded asynchronously from a CSV using `d3.csv` and displayed without interaction.

Migrant Deaths

A line chart displays the total number of dead and missing migrants over time, with each reported date plotted along the x-axis and the corresponding death count on the y-axis. The visualization uses React with D3 v7, employing `scaleTime`, `scaleLinear`, `line`, and `curveCardinal` to generate the smooth path and individual data points. Data is loaded from a CSV file containing global migrant incidents. Small circles with tooltips on hover provide additional details for each date.

World Map v3

A world map visualization displays the Earth's landmasses and 2020 UN population data for cities, with each city represented as a circle whose radius is proportional to its population. The map uses D3.js v7's geoNaturalEarth1 projection, geoPath, and geoGraticule for the geographic features, while the data is rendered as SVG circles with square-root scaled radii. Population data comes from a CSV file of world cities, and the map is built using React's state management to load and display the atlas and population datasets.

World Map v2

This example displays a world map with cities plotted as points, using a natural Earth projection to render country boundaries, graticules, and a sphere outline. The visualization loads geographic data from a TopoJSON world atlas and city coordinates from a CSV file, then projects them using d3.geoNaturalEarth1 and d3.geoPath. React manages the component state and rendering, while d3.csv and d3.json fetch the datasets. The map is drawn entirely in SVG, with each city represented as a small circle positioned by its longitude and latitude.

Iris Scatter Plot v5

This interactive scatter plot visualizes the Iris dataset, showing measurements of sepal and petal dimensions for three flower species. Users can select which attribute appears on each axis using dropdown menus, while points are color-coded by species with a legend on the right. The visualization uses D3 v7 scales and axes for positioning, React with hooks for state management, and renders points as SVG circles with native tooltips. Data is loaded as CSV and parsed by D3's csv loader.

Iris Scatter Plot v4

This interactive scatter plot displays the classic Iris dataset, plotting sepal and petal measurements for three flower species. Users can change the x- and y-axis variables via React dropdown menus, with each species consistently colored using a d3.scaleOrdinal mapping to teal, purple, and orange. The visualization leverages React state hooks for dynamic updates, d3.csv for data loading, and d3.scaleLinear for axis scaling. Custom React components render SVG axes and circle marks with native tooltips.

Iris Scatter Plot v6

This interactive scatter plot visualizes the Iris flower dataset, displaying sepal and petal measurements for setosa, versicolor, and virginica species. Users can select which attributes appear on the x- and y-axes via React dropdown menus, while hovering over the color legend highlights only matching species points with d3 scaleOrdinal color mapping. The visualization uses React hooks for state management, d3.csv for data loading, and d3.scaleLinear for axis scaling, with SVG rendering for all marks and axes.

Iris Scatter Plot v3

This interactive scatter plot visualizes the Iris dataset, plotting sepal and petal measurements against each other. Users can select different attributes for the x and y axes via dropdown menus, with each circular mark representing an individual flower. The visualization uses React components with D3 v7 scales (scaleLinear) and the extent function to compute domains, rendering SVG circles with hover tooltips. Data loads asynchronously from a CSV file using the d3.csv method.

Nov 3, 2021

Iris Scatter Plot v2

This interactive scatter plot visualizes the Iris dataset, allowing users to explore relationships between sepal and petal measurements by selecting which attribute appears on each axis. The React-based interface uses dropdown menus to swap the x and y variables, while d3.scaleLinear and d3.extent handle the scales and domains. Data is loaded from a CSV file using d3.csv, and the SVG rendering uses custom React components for axes and circular marks.

Nov 3, 2021

Drop Down

This example demonstrates a pet selector interface built with React and D3. It shows a dropdown menu populated with five pet options, defaulting to "Dog," and logs the selected value to the console. The implementation uses React's `useState` hook to manage the selected value and a custom `DropDown` component that renders an HTML `<select>` element. The component accepts `options`, `selectedValue`, and an `onSelectedValueChange` callback, triggering the state update on user interaction. The code relies on React 16.9 and ReactDOM for rendering.

Nov 2, 2021

React Starter

This example demonstrates a minimal React application that renders a simple "Hello React!" message in the browser. It uses React 16.9.0 and ReactDOM to mount a functional component into a root div, while D3 is not directly utilized despite the README referencing a smiley face implementation. The code loads React via CDN scripts and creates a static, single-element UI without any interactive data visualization or charting logic.

Nov 2, 2021

World Map

This visualization displays a world map with countries rendered in teal against a light blue sphere, with graticules and interior borders shown in subtle gray strokes. It uses D3’s geoNaturalEarth1 projection and geoPath to draw geographic features from TopoJSON data loaded via d3.json and processed with topojson’s feature and mesh functions. The React-based component sets the SVG dimensions to the full window size, and the map is styled with CSS classes for distinct visual layers.

Nov 2, 2021

Iris Scatter Plot v1

This interactive scatter plot displays sepal length against sepal width for the classic Iris dataset, with each of the 150 flowers represented as a teal circle positioned by linear scales. The visualization includes labeled axes with formatted tick marks and hover tooltips that reveal exact sepal length values. Built with React and D3 v7, the code uses d3.scaleLinear and d3.extent to map data coordinates to SVG space, while custom React components (AxisBottom, AxisLeft, and Marks) render the axes and circles from CSV data loaded via d3.csv.

UN Population Bar Chart v5

This horizontal bar chart displays the 20 most populous countries in 2020, with bars extending left-to-right from a shared baseline. The visualization uses D3 v7’s scaleBand and scaleLinear to map country names to y-axis positions and population values to bar widths, rendered as SVG rectangles in React. The data is loaded from a remote CSV, with tick labels formatted using D3’s format function, converting values to billions. The chart includes styled axes and a population label, with hover tooltips provided by native SVG `<title>` elements.

UN Population Bar Chart v4

This bar chart displays the 20 most populous countries in 2020, ranked vertically by country with horizontal bars proportional to population size. The visualization uses React components with D3 v7 scales, including `scaleBand` for the categorical y-axis and `scaleLinear` for the numeric x-axis. Data is loaded via D3’s `csv` function from a GitHub-hosted dataset, with axes rendered as custom SVG elements using `AxisBottom` and `AxisLeft`.

UN Population Bar Chart v3

This visualization displays the populations of the top ten countries from a UN 2020 dataset as horizontal bars, using a bar chart format. The chart scales population values linearly on the x-axis and country names using a band scale on the y-axis. Built with React and D3 v7, it loads the CSV data via `d3.csv` and renders SVG elements directly, including axis ticks and grid lines. The visualization fills the browser window and updates asynchronously once the data is fetched.

UN Population Bar Chart v2

A horizontal bar chart shows the populations of the ten most populous countries in 2020, based on UN data loaded from a CSV file. Built with React and D3 v7, it uses `d3.csv` to fetch and parse the data, then renders SVG rectangles scaled by `d3.scaleLinear` for population values and `d3.scaleBand` for country categories. The chart fills the browser window and updates after data loads.

UN Population Bar Chart

This visualization displays the top 10 most populous countries in 2020 as horizontal bars, with bar length proportional to population. The React component loads the UN population dataset via d3.csv, then renders an SVG using scaleBand for the categorical country axis and scaleLinear for the population values. The chart fills the entire browser window (width and height set to window dimensions) and updates only after the data loads, initially showing a large “Loading…” message. The code uses React hooks (useState, useEffect) to manage the asynchronous data fetching and D3’s scale functions for mapping data to pixel coordinates.

MDN: CSS Color Wheel

This example renders a radial burst of all named CSS colors as a pie chart, with each slice filled by its corresponding hex value. The visualization uses React to manage state and render the SVG, while D3 v7’s `csv` loader fetches the color data from a GitHub gist and `pie` and `arc` compute the slice geometry. The chart fills the entire viewport, with slices radiating from the center to the window’s edge.

Vega-Lite API Template

This example visualizes automobile data from the UCI Machine Learning Repository’s Auto MPG dataset, plotting origin on the x-axis, horsepower on the y-axis, and encoding mpg as circle size with tooltips showing car names. Built with the Vega-Lite API, it registers vega, vega-lite, and vega-tooltip in index.js, loads CSV data via d3.csv, and renders an interactive SVG chart configured with custom axis and label styling from config.js. The visualization updates dynamically to fit the browser window.

Loading Data with React and D3

A React application loads a CSV file of CSS named colors from a GitHub gist and displays basic statistics about it in a large HTML `<pre>` element. The example shows a loading message before the data arrives, then replaces it with the file size in kilobytes, row count, and column count. The code imports `csv` and `csvFormat` from D3 v7 to fetch and measure the data, while React's `useState` and `useEffect` hooks manage the asynchronous download. Rendering is entirely text-based, with no SVG or visual chart.

Loading and Parsing CSV Data

This example demonstrates the basic operation of loading and parsing a CSV file using D3 v7. It fetches a remote dataset of CSS named colors and displays its file size in kilobytes, row count, and column count within a large `<pre>` element. The code uses the `d3.csv` method to retrieve and parse the data, then accesses the parsed array’s `length` and `columns` properties. A `d3.csvFormat` call calculates the formatted size, while the commented alternative shows fetch with async/await and `d3.csvParse`.

Mouse Follower

A bright yellow circle tracks the mouse cursor across a full-screen SVG canvas, reacting instantly to pointer movement. The React-based application uses the `useState` hook to store the cursor's current `clientX` and `clientY` coordinates, updating the circle's center position on every mouse move event. Rendered through ReactDOM with SVG elements, the visualization demonstrates a simple interactive feedback loop between user input and graphical output.

Hello HTML

A grid of 18 randomly generated cartoon faces demonstrates how React components can compose SVG primitives with D3-generated paths. Each face uses the reusable `Face` component, which assembles a yellow `Head` circle, two `Eyes` circles, and a `Smile` path created via `d3.arc()` with randomized inner and outer radii. Face features vary per instance through props like `eyeOffSetX`, `stkWidth`, and `smileRadius`, while `ReactDOM.render` places all faces into the DOM. The example highlights mixing declarative React state with D3’s arc generator for parameterized visual output.