j-PGi

Covid Log Scale

This visualization tracks global COVID-19 cumulative deaths over time, plotting each country as a separate colored line. It uses a logarithmic y-scale to compress the wide range of death tolls, making early growth patterns visible across all countries simultaneously. The chart is built with React and D3 v5, using `d3.scaleLog` for the y-axis, `d3.line` for path generation, and `d3.axisBottom`/`d3.axisLeft` for gridlines and ticks. Data comes from the CSSE COVID-19 time series CSV, with dates parsed via `d3.timeParse`.

Aug 6, 2021

React + D3 Axis

This chart visualizes the cumulative global death toll from COVID-19 over time, sourced from the Johns Hopkins CSSE time-series data. Using React components, it leverages D3 functions such as `scaleTime`, `scaleLinear`, `line`, and `axisBottom` to create an SVG line chart, with horizontal and vertical marker lines highlighting the 3,000,000 death milestone and the most recent date. The chart’s axes are drawn via D3’s `axisBottom` within a React `useRef`/`useEffect` wrapper, while CSS styles the tick marks and line.

Aug 5, 2021

Fork of Coronavrius Line Chart with marker line

A COVID-19 line chart displays the global total of deaths over time using a React component with D3 v5 scales and path generators. The chart plots daily cumulative death counts from the CSSE time series dataset, with a horizontal marker line at 3,000,000 deaths and a vertical marker line at the most recent date labeled "Now." Both marker lines are implemented as React components using D3’s `scaleLinear` and `scaleTime` to position them within the SVG viewport. The line path is generated with `d3.line` and styled with CSS.

Aug 5, 2021

Coronavrius Line Chart with marker line

A line chart tracks cumulative global COVID-19 deaths over time, using a black marker line to highlight the point where the death toll reaches three million. The visualization loads time-series data from the Johns Hopkins CSSE repository via `d3.csv`, transforms dates with `d3.timeParse`, and renders an SVG path generated with `d3.line`. Scales are created with `d3.scaleTime` and `d3.scaleLinear`, while React manages the component state and updates the chart.

Aug 4, 2021

Coronavrius Line Chart

A line chart titled “Coronavirus” displays the cumulative global death count from the COVID-19 time series, using the latest date column from the JHU CSSE data. The example fetches the CSV via `d3.csv`, maps each row’s last date value to a number, and reduces the array with a sum accumulator. It then formats the total with `d3.format(',' )` and displays the result as a large-text message in a `<pre>` element. No actual line geometry is drawn; instead, the visualization conveys the single data point through typography.

Aug 3, 2021

Summarizing Coronavrius Data

A dashboard shows the global cumulative death count from the COVID-19 pandemic, displaying the total as a large number alongside the most recent date in the dataset. It loads time-series data from the CSSE at Johns Hopkins via `d3.csv`, extracts the final column for the latest date, and sums all row values using a `reduce` operation. The result is formatted with `d3.format` and rendered as plain text inside an HTML `<pre>` element. The visualization is intentionally minimalist, focusing solely on the aggregate statistic rather than trends or geographic distribution.

Aug 3, 2021

Fork of Loading and Parsing Coronavrius Data

This example demonstrates the size and structure of a COVID-19 global deaths dataset by displaying three metrics in a large text readout: file size in kilobytes, row count, and column count. It loads the Johns Hopkins University time-series CSV directly from GitHub using `d3.csv`, then calculates the formatted data’s byte length with `d3.csvFormat`. The results are written into a DOM element via `textContent`, showing how many rows and columns the dataset contains without any visual chart or rendering.

Aug 3, 2021

HIV/AIDs Choropleth Map

This example displays a choropleth map of HIV/AIDS prevalence among adults aged 15–49 for the year 2017, using a sequential yellow-orange-red color scale to indicate infection rates. Country boundaries come from World Atlas TopoJSON, with graticules and interior borders rendered for visual polish. The React app loads CSV data on HIV prevalence and ISO country codes, joins them by numeric code, and projects the map using d3.geoNaturalEarth1 and d3.geoPath. Missing data appears in grey, and the visualization updates via d3.scaleSequential with interpolateYlOrRd.

Aug 2, 2021

Missing Migrants Scatter Plot Log Scale

This scatter plot visualizes the Missing Migrants Dataset, with each point representing a single migration event. The x-axis encodes reported dates using a time scale, while the y-axis uses a logarithmic scale to display the total number of dead and missing, compressing large values for clarity. Built with React and rendered as SVG, the visualization uses d3.scaleLog, d3.scaleTime, and d3.csv for data loading. Axis components are custom React functions that generate tick marks and labels, with tooltips on each circle showing the exact date.

Aug 2, 2021

Multiple Views with Brushing

Two coordinated views show migrant deaths and disappearances worldwide. A bubble map projects incidents using `d3.geoNaturalEarth1` and `geoPath`, with circle radii scaled by `scaleSqrt`. A time histogram beneath aggregates monthly totals using `d3.bin` and `sum`. Interactive `brushX` brushing filters map circles by date range, linking the views. Data comes from the Missing Migrants Project CSV, rendered as SVG in React with D3 v5.

Multiple Views

This example combines a bubble map and a date histogram to visualize the geographic distribution and temporal trends of migrant deaths and disappearances. A world map using `geoNaturalEarth1` and `geoPath` displays circles sized by the total dead and missing per location, while a time-series histogram below aggregates the same data by month using `bin` and `scaleTime`. The visualization is built with React and D3 v5, using SVG rendering and data from a CSV of global migrant incidents.

Missing Migrants on a Map

This visualization maps the global distribution of missing migrants, using semi-transparent circles to represent the total number of dead and missing individuals at each recorded location. The geographic context is provided by a natural Earth projection rendered with D3’s `geoNaturalEarth1` and `geoPath`, overlaid with graticules and country boundaries from World Atlas TopoJSON. Circle radii are scaled with a square-root scale based on the data’s maximum value. The React app fetches data from a CSV and JSON from external sources, leveraging `scaleSqrt` and `useWorldAtlas` hooks to load and process both datasets.

Missing Migrants

This chart displays the total number of dead and missing migrants over time, aggregated into monthly bins from the Data Canvas Sense Your City Dataset. It uses a histogram layout, with bars representing the sum of casualties per month. The visualization is built with React and D3 v5, using `d3.histogram` for binning, `d3.scaleTime` and `d3.scaleLinear` for axes, and renders SVG rectangles for marks. Tooltips appear on hover via SVG `<title>` elements.

Points on a Map

A world map displays country boundaries and graticules over a light gray sphere, with semi-transparent teal circles sized by city population. The visualization uses d3.geoNaturalEarth1 for projection and d3.geoPath to render land, interiors, and sphere outlines from TopoJSON data. City coordinates are projected and drawn as SVG circles, with radii scaled using d3.scaleSqrt applied to population values from a CSV dataset. The React component structure manages state for both world atlas and city data.

Scatter Plot with Interactive Legend

A scatter plot of the Iris dataset rendered in SVG using React and D3 v5. It displays measurements of iris flowers, with dropdown menus to switch the X and Y axes between sepal and petal dimensions, alongside a color-coded legend for species. Hovering over a legend entry fades non-matching data points, implemented through React state and D3's `scaleLinear` and `scaleOrdinal`. The plot includes axis ticks and labels from custom React components, with data loaded via `d3.csv`.

Scatter Plot with Legend

This example shows an interactive scatter plot of the Iris Dataset, where users can choose which numeric attribute to display on the x- and y-axes via dropdown menus. Each point represents a flower sample, colored by species and accompanied by a legend. The visualization is built with React and rendered as SVG, using d3.scaleLinear and d3.scaleOrdinal for scales, while d3.csv loads the data from a remote gist.

Jul 30, 2021

Polished Scatter Plot with Menus

This interactive scatter plot displays the Iris dataset, allowing users to explore relationships between flower measurements by selecting different attributes for the x and y axes through dropdown menus. Built with React and rendered as SVG, the visualization uses D3.js functions such as `scaleLinear`, `extent`, and `format` to map data ranges and format tick labels. Each point is a circle with a native SVG `<title>` element for hover tooltips, positioned using computed coordinates from the D3 scales. The plot features labeled axes, styled tick marks, and a dark teal color scheme.

Jul 29, 2021

Scatter Plot with Menus

This interactive scatter plot displays the Iris Dataset, allowing viewers to explore relationships between different floral measurements by selecting which attributes to plot on the X and Y axes through two dropdown menus. Built with React and D3 v5, it uses the `scaleLinear` API to map data to SVG coordinates, with custom `AxisBottom`, `AxisLeft`, and `Marks` components rendering the axes and circle glyphs. The visualization updates dynamically when menu selections change, and each data point includes a native SVG tooltip showing its value.

Jul 29, 2021

Menus with React

A React app demonstrates a controlled dropdown menu for selecting a pet from a defined list. The interface pairs a label with a custom `Dropdown` component, which builds a native `<select>` element from an options array. User selections update React state via the `useState` hook, and the chosen value is logged to the console. The example uses React 17, `ReactDOM.render`, and a reusable component pattern to manage UI state without external charting libraries.

Jul 28, 2021

React Starter

This example demonstrates a minimal React application that renders the text “Hello React!” inside a full-screen viewport. It uses React 16.7.0 and ReactDOM to mount the component into a root `<div>`, with plain inline styling to remove default margins and hide overflow. The code imports the `react` and `react-dom` libraries, defines a simple functional component, and calls `ReactDOM.render` to attach it to the DOM. No data visualization or external data source is involved; the purpose is to provide a clean starting point for building more complex React-based visualizations.

Jul 28, 2021

World Map

This example displays a world map using a Natural Earth projection, with landmasses rendered in teal and graticules drawn as light gray lines. It shows a sphere outline and country border lines derived from the world-atlas TopoJSON dataset. The visualization uses d3.geoNaturalEarth1 and d3.geoPath to project geographic features into SVG paths, while d3.geoGraticule generates the latitude and longitude grid. React handles rendering through a Marks component, and TopoJSON’s feature and mesh functions extract land polygons and interior boundaries from the source data.

Jul 28, 2021

Working with time

This example visualizes temperature readings over time using a smooth line chart, with time on the x-axis and temperature on the y-axis. The data comes from a CSV file containing weekly San Francisco temperature records. The visualization is built with React and renders to SVG, using d3.scaleTime and d3.scaleLinear for the axes. d3.line with curveNatural draws the path, while the axis components generate ticks and labels. Tooltips are commented out in the Marks component.

Jul 27, 2021

Stylized Scatter plot

This stylized scatter plot visualizes the Iris dataset, plotting sepal length against sepal width for each flower specimen. Built with React and D3 v5, it uses SVG rendering with custom axis components and circular marks. The visualization employs D3's `scaleLinear` for axis scaling, `extent` to compute data domains, and `format` for tick label formatting. Data is loaded asynchronously from a CSV file via D3's `csv` function, with a clean, minimalist design using the Poppins font and a muted color palette.

Jul 26, 2021

Stylised Refactored Bar Chart

A stylised horizontal bar chart displays the ten most populous countries in 2020, sourced from UN population data loaded via `d3.csv`. Rectangular marks are rendered with React, using `d3.scaleBand` for the categorical y-axis and `d3.scaleLinear` for the numeric x-axis. Axis components generate ticks and labels in SVG, with tooltips formatted using `d3.format` and custom styling applied through Poppins typography and muted teal fills.

Refactored Bar Chart

This example presents a horizontal bar chart displaying the top 10 most populous countries for the year 2020, sourced via a CSV from the UN Population dataset. Built with React and D3 v5, it uses D3’s `scaleBand` and `scaleLinear` to compute scaling and relies on custom components for axes and marks. The chart renders as an SVG through React components, with D3’s `csv` utility fetching and parsing the data.

Margins and Axes

This visualization displays a horizontal bar chart of the top 10 most populous countries for 2020, using data from the UN Population dataset loaded via `d3.csv`. React manages the application state and renders SVG elements, while D3's `scaleBand` and `scaleLinear` compute the chart’s scales and ticks. The chart includes labeled axes with margins, using a 200-pixel left margin for country names and a 20-pixel margin elsewhere.

Making a Bar Chart with React & D3

This example demonstrates a bar chart that ranks the ten most populous countries in 2020, using a horizontal layout where bar length corresponds to population size. The visualization uses React for declarative SVG rendering, with D3.js utilities handling data loading via `d3.csv`, creating categorical scales with `d3.scaleBand`, and continuous scales with `d3.scaleLinear` and `d3.max`. The code fetches population data from a CSV URL and transforms each row before rendering the bars as SVG rectangles.

Fork of Vega-Lite API Template

This example shows a line chart of weekly temperature readings from San Francisco, using Vega-Lite’s declarative API. The chart encodes time on the x-axis and temperature on the y-axis, with a tooltip revealing the precise temperature value per point. The visualization is built with the `vega-lite-api` library, which registers Vega and Vega-Lite, and loads data via `d3.csv`. It renders interactively to an SVG, sized to the window, with custom axis and label styling from a configuration object.

Jul 23, 2021