J

jiro2017

@jiro2017·20 public vizzes

Loading thumbnail…

Fork of React Starter

This example demonstrates a React component that lets users select a pet from a dropdown menu, with the current choice displayed alongside the label. Using the `useState` hook, the app manages the selected value and passes it to a reusable `Dropdown` component, which renders a `<select>` element with options defined in an array. The code integrates React 16.9 and ReactDOM 16.7 with D3 v7 loaded via CDN, though no D3 visualization is used here. The interaction is handled through the `onChange` event, updating state and re-rendering the selection.

Loading thumbnail…

Polished Scatter plot with Menus

This example visualizes the Iris dataset as an interactive scatter plot, letting users choose which flower measurements appear on the x- and y-axes through dropdown menus built with React and react-dropdown. The plot renders points as SVG circles, with axes generated using custom React components that call d3.scaleLinear for scaling and d3.extent for domain computation. Data loading is handled by d3.csv, which parses numeric columns for the four measurement attributes. The visualization supports tooltips on hover and uses D3’s format function to display compact axis tick labels like “1.5B”.

Loading thumbnail…

Scatter plot with Menus

This interactive scatter plot displays the Iris dataset, showing the relationship between two user-selected measurements. Dropdown menus allow viewers to choose which flower attributes appear on the x- and y-axes, with the plot updating dynamically on selection. The visualization is built using React for state management and D3 v7 for scaling, axes, and SVG circle rendering, drawing data from a remote CSV file.

Loading thumbnail…

React Starter

This example demonstrates a minimal React application that renders a static text message, “Hello React,” centered on a plain white page. It shows a basic integration of the React and ReactDOM libraries within an HTML document, using the `ReactDOM.render` API to mount the component into a root `<div>` element. The page loads React 16.7.0 and ReactDOM 16.7.0 from unpkg, along with D3 v7.0.1, although this code does not invoke any D3 functions. The styling sets the body font size to 13em, producing oversized text that fills the screen.

Loading thumbnail…

World Map

This example renders a world map using the Natural Earth projection, displaying country boundaries and graticule lines. The visualization shows landmasses filled with a teal color, country interiors outlined, and the sphere background in light gray. The code uses React for component structure and d3-geo functions like `geoNaturalEarth1` and `geoPath` to project and draw geographic features. TopoJSON data from the world-atlas package is loaded and converted to GeoJSON using `feature` and `mesh`.

Loading thumbnail…

Working with Time

This visualization shows a week of temperature readings in San Francisco as a smooth line chart, with points marking each hourly measurement. The time axis uses a time scale and formats tick labels as abbreviated weekday names. Built with React and D3 v7, the chart uses `scaleTime`, `scaleLinear`, `line` with `curveNatural`, and custom `AxisBottom` and `AxisLeft` components to render the SVG. Data comes from the Data Canvas Sense Your City API, loaded via `csv`, with tooltips on points displaying the formatted timestamp.

Loading thumbnail…

Stylized Scatter Plot

This scatter plot visualizes the Iris dataset, displaying petal length on the x-axis and sepal width on the y-axis, with each flower represented as a teal circle. Built with React and D3 v7, the visualization uses d3.scaleLinear for both axes and d3.extent to compute the domain from the data. SVG circles render the marks, while React components for the axes and marks handle the tick lines, labels, and hover tooltips. The data loads asynchronously via d3.csv from a remote gist, and the chart applies a custom Poppins font and muted color palette.

Loading thumbnail…

Stylized Bar Chart

This stylized bar chart displays the population of the ten most populous countries using data from the UN Population 2019 dataset. The chart employs D3 scales (scaleBand and scaleLinear) to map country names and population values to SVG rectangles, with React components handling the rendering. CSS styled axes and tick marks are generated using D3’s scale methods. A native SVG `<title>` element provides tooltip support, showing formatted population values. The visualization utilizes a custom React hook with d3.csv to load and process data, presenting it through a clean, minimal aesthetic with Poppins typography.

Loading thumbnail…

Refactored Bar Chart

This example presents a horizontal bar chart of United Nations population data for ten countries, sourced from a CSV file. It shows population values for 2020 using the D3 scale functions `scaleBand` and `scaleLinear` to map countries and populations to SVG coordinates. React components render the marks and axes, with `AxisBottom` drawing tick lines and labels, and `AxisLeft` displaying categorical labels. The chart is built declaratively, avoiding explicit loops, by mapping over scales and data within the component JSX.

Loading thumbnail…

Axes with react D3

This example shows a horizontal bar chart of the top 10 countries by population in 2020, using React to render SVG elements and D3 to handle data loading and scales. The code loads CSV data from a remote URL with `d3.csv`, then uses `scaleBand` for the country axis, `scaleLinear` for the population axis, and manually creates tick marks and labels for both axes. Each country is represented as a `rect` whose width corresponds to its population.

Loading thumbnail…

The Margin Convention

This example demonstrates the “margin convention” for D3 visualizations by rendering a horizontal bar chart of population data for ten countries in 2020. A React component uses the `useState` and `useEffect` hooks to load CSV data via `d3.csv`, then computes scales with `scaleBand` and `scaleLinear`. The SVG output positions all bars within a translated `<g>` element based on specified margin values, with `d3.max` determining the x-domain. The chart updates from a loading state to display the final encoded bars.

Loading thumbnail…

Fork of Rendering data with React

This example shows a horizontal bar chart of the top 10 most populous countries in 2020, using D3 utilities to load and scale the data and React to render the SVG bars. The code uses `d3.csv` to fetch population data from a gist, `d3.scaleBand` for the categorical y-axis, and `d3.scaleLinear` for the quantitative x-axis. Each country is drawn as a React `<rect>` component within an SVG, with bar widths proportional to population values.

Loading thumbnail…

Rendering data with React

This example shows a radial burst visualization of CSS named colors, with each color displayed as a wedge in a full circle. It loads color data from a CSV file using the `csv` function from d3.v7, then transforms it with the d3 `pie` generator and renders it as SVG paths using React components. The `arc` generator sets the inner radius to zero and the outer radius to the full width, while React’s `useState` and `useEffect` hooks manage the asynchronous data loading. Each path’s fill property is set from the `RGB hex value` column in the dataset.

Loading thumbnail…

Rendering data with React

A React app renders a horizontal stacked bar chart of CSS named colors, loading the data from a CSV of color names and hex values. The interface shows a “Loading” state before the data arrives, then displays each color as a thin colored stripe using inline styles, with the total width fixed at 960 pixels. The code uses React’s `useState` and `useEffect` hooks to fetch data with `d3.csv`, and renders the result as a list of `div` elements, avoiding SVG or canvas.

Loading thumbnail…

Fork of Loading and Parsing CSV Data

This example demonstrates how to load and parse a remote CSV file, then display a summary of its size and structure as plain text. Using D3 v7's `d3.csvParse` alongside the Fetch API, the program retrieves a list of CSS named colors from a GitHub gist, counts the rows and columns, and estimates the file size in kilobytes. The result appears in a large-font message container, offering a minimal proof-of-concept for asynchronous data handling with D3 and native browser features.

Loading thumbnail…

Vega-Lite API Template

This example visualizes the world’s most populous religions by country using a bubble chart, where each circle’s size encodes the population count. Hovering reveals the exact population via tooltips. Built with the Vega-Lite API, it registers Vega and Vega-Lite, fetches CSV data from a GitHub gist using D3’s `csv` method, and applies custom axis and font styling from a separate config module. The chart fills the browser window and renders as SVG.

Loading thumbnail…

Loading data with react d3

This example demonstrates how to load external data with D3 utilities while managing the resulting state within a React component. The app fetches a CSV file containing CSS named colors using `d3.csv` and displays summary statistics about the dataset—row count, column count, and approximate file size—inside a simple `<pre>` element. During the asynchronous fetch, it shows a "Loading..." message. The implementation uses React hooks like `useState` and `useEffect`, along with `d3.csvFormat` for calculating data size, rendering the output as SVG-less plain text.

Loading thumbnail…

Loading and Parsing CSV Data

This example demonstrates the initial step of working with CSV data in D3: loading a remote file and parsing it into a usable dataset. It fetches the `CssNamedColors.csv` file from a GitHub gist using the Fetch API, then applies `d3.csvParse` to convert the raw text into an array of objects. The code calculates and displays the total number of rows, columns, and file size in kilobytes within a large text element. It uses `d3.csvParse` and the built-in `fetch` method under D3 v7.

Loading thumbnail…

A Program that follows your mouse with a circle

A circle follows the mouse cursor across a full-screen SVG canvas, updating its position in real time. The visualization uses React state to track the cursor's clientX and clientY coordinates, triggered by an onMouseMove event handler on the SVG element. Built with React 16.9 and D3 v7, the circle is rendered directly as an SVG `<circle>` element, with its cx and cy attributes bound to the current mouse position. No data source is involved; the interaction is purely event-driven.

Loading thumbnail…

Smiley face description

A composite smiley face built from React components renders a yellow circle with black stroke, two offset eyes, and a d3 arc-based mouth. The SVG is centered via a translated group, with parameters for face dimensions, eye placement, and mouth curvature passed through a reusable component hierarchy. The d3 `arc` API generates the mouth path, while the face remains static, defined entirely by explicit props.