John Patrick Banas

Polished Scatterplot with Menus

This interactive scatterplot displays measurements from the Iris dataset, plotting petal and sepal dimensions on the x and y axes. Users can switch both axes between the four numeric attributes via ReactDropdown menus, with axis labels updating accordingly. The visualization is built with React and D3 v5, using d3.scaleLinear for the scales and d3.csv for data loading. Each circle includes a native SVG <title> element for tooltips, while the styling uses a Poppins font and muted colors.

Sep 12, 2021

Scatter Plot with Menus

This interactive scatter plot displays the Iris flower dataset, allowing users to compare any two attributes by selecting them from dropdown menus for the X and Y axes. The visualization updates dynamically, with axis labels and scales recalculating to reflect the chosen measurements. Built with React and D3 v5, it uses `scaleLinear` and `extent` to derive scales, renders SVG circles for each data point, and organizes its code into reusable components for axes, marks, and dropdowns. The data is loaded from a CSV file via D3’s `csv` function.

Menus with React example

A React application demonstrates a controlled dropdown menu for selecting a pet, with the chosen value displayed in a label. The code uses React's `useState` hook to manage the selected state and a reusable `Dropdown` component that renders an HTML `<select>` element with `onChange` event handling. Options come from a static array of pet name-value pairs, and the interface is rendered via `ReactDOM.render` into a root div.

React Starter

This example shows a minimal React application that renders the text "Hello React!" into a web page. It uses React 17 and ReactDOM to mount a functional component into a root div. The HTML file loads React and ReactDOM from a CDN and applies basic CSS to remove margins and hide overflow, while the JavaScript file defines the App component and calls ReactDOM.render to display it. It demonstrates a simple setup for integrating React with a visualization environment.

Line Chart Temperature Variations

This line chart displays temperature variations over a week in San Francisco, with a smooth curve connecting data points and tooltips showing the day for each point. The visualization uses React for component structure and D3 v7 APIs including `scaleTime`, `scaleLinear`, and `line().curve(curveNatural)` for rendering. The SVG output includes custom `AxisBottom` and `AxisLeft` components with labeled axes. Data is loaded from a CSV file using D3's `csv` function, with timestamps parsed as JavaScript Date objects and temperatures converted to numbers.

Iris Species Stylized Scatter Chart

This stylized scatter chart displays sepal length and width measurements for Iris species, with each point represented as a teal circle. The visualization uses React components for rendering SVG elements, including custom axis and mark components that leverage d3.scaleLinear for coordinate mapping. Data is loaded asynchronously from a GitHub gist via d3.csv, with numeric parsing applied to the four measurement columns.

Stylized Bar Chart

This stylized horizontal bar chart displays the population of ten countries in 2019, sourced from UN data. Using React and D3 v7's `scaleBand` and `scaleLinear`, the JavaScript code renders SVG elements to visualize the distribution. The chart applies custom styling from the Sunlight Foundation's data visualization guide, including the Poppins font and a muted color palette for axes and marks.

Refactored Bar Chart

This bar chart displays the population of ten countries, with country names on the vertical axis and population values on the horizontal axis. The visualization builds on React and D3 v7, using `scaleBand` for the categorical y-axis and `scaleLinear` for the quantitative x-axis. The chart is modularized into separate components for the bottom axis, left axis, and bar marks, with a custom `useData` hook that loads CSV data via `d3.csv`. The SVG rendering is driven by a React state-managed data pipeline.

Axes with Reactsies

This example shows 2019 population data for ten countries as horizontal bars with SVG axes built manually. React state manages the CSV data loaded via `d3.csv`, while `scaleBand` positions countries along the y-axis and `scaleLinear` maps population values to bar widths. The code generates tick marks and labels by iterating over `xScale.ticks()` and the y-domain, drawing grid lines and text with SVG elements.

Margin Convention

A bar chart displays the ten most populous countries using UN population data for 2019. The D3 v7 scales, `scaleBand` and `scaleLinear`, map country names and population values to SVG rectangles. React state manages the asynchronous loading of the CSV via D3's `csv` function. The chart applies the margin convention by translating a group element, reserving space for axes and labels within a 960 by 500 viewport.

United Nations Data for World Population

This example visualizes the top 10 most populous countries in 2019 using a horizontal bar chart. The chart loads United Nations population data from a CSV file via `d3.csv` and processes each row to extract the `2019` population value. React state manages the loaded data, and D3’s `scaleBand` and `scaleLinear` position and size the SVG rectangles. The visualization is rendered with React and SVG, showing population counts as bar widths.

Use d3 arcs

This example visualizes a dataset of CSS named colors as a pie chart, with each slice filled using its corresponding RGB hex value. The visualization leverages React state to manage asynchronous data loading via D3’s `csv` utility. D3’s `pie` generator computes the arc angles, while the `arc` function renders the SVG paths. The chart is centered on an SVG canvas, and the data source is a remote gist containing color names and hex codes.

PieChart for CSS Colors

This example visualizes CSS color data as a sequence of horizontal bars, each displaying a named color’s RGB hex value as its background. The app loads the dataset from a GitHub Gist using D3’s `csv` utility, then stores it in React state via the `useState` and `useEffect` hooks. Each row is rendered as a `div` element with inline styles for width and height, effectively creating a color swatch list. React 16.9 and D3 v7 are used together, with SVG elements commented out in the HTML template.

Vega-Lite API Template

This example demonstrates an interactive scatterplot of automobile data, plotting acceleration against horsepower with points colored by origin. Built using the Vega-Lite API, the visualization renders via SVG and includes tooltips displaying car names. The code loads data from a CSV using d3.csv, registers Vega-Lite with vega and vega-tooltip, and configures axes and label styling. The visualization auto-fits its container dimensions and uses a custom dark color scheme.

Loading Data with React & D3

This example demonstrates how to load external data in a React application using D3 utilities, displaying a summary of the dataset’s size, row count, and column count. The code uses the `useState` and `useEffect` hooks to manage data asynchronously, calling `d3.csv` to fetch a CSV file from a GitHub gist. Once loaded, the data is rendered as plain text in a `<pre>` element, with a “Loading…” placeholder shown until the fetch completes. The visualization highlights the integration of React’s state management with D3’s data-loading APIs.

Loading and Parsing CSV Data

This example demonstrates how to load and parse a CSV file using D3 v5, displaying the file size, row count, and column count in large text. It uses `d3.csv` to fetch and parse the dataset asynchronously via a promise, then formats a summary message with `d3.csvFormat` to calculate kilobyte size. The data source is a GitHub-hosted CSV containing CSS named colors. An alternate approach using the Fetch API with `async` and `await`, plus `d3.csvParse`, is included as commented-out code for comparison.

Mouse Follower

A yellow circle follows the mouse cursor across a full-screen SVG canvas. The React component tracks pointer coordinates via an `onMouseMove` event handler, storing them in state with `useState` and updating the circle’s `cx` and `cy` attributes. The visualization uses `ReactDOM.render` to mount the app, with the circle’s radius fixed at 30 pixels.

Sep 9, 2021