Rajat Dangat

Working with Time

This example visualizes a week of temperature readings in San Francisco as a scatter plot, with time on the x-axis and temperature on the y-axis. Each circle represents a single measurement, and hovering reveals the exact timestamp. Built with React and D3 v5, the visualization uses `scaleTime` and `scaleLinear` to map data to SVG coordinates, while custom `AxisBottom` and `AxisLeft` components render the ticks. The code loads data from a CSV file containing the "Data Canvas Sense Your City" dataset and formats the time axis using `timeFormat("%a")` for day abbreviations.

May 24, 2021

Animated eye

The animated eye is a playful React visualization that renders a stylized, rotating eye shape on a dark background, with a central pupil and iris built from nested CSS circles. Hovering over the eye triggers a smooth eyelid closure, simulated by a red overlay that expands vertically. The code uses React 16.13.1 and ReactDOM to mount the component, while all animation and geometry are handled entirely through CSS3 properties, including transforms, border-radius, and transitions on the `.shut span` element. The rendering approach is purely DOM-based with no external data or JavaScript animation libraries.

Apr 22, 2021

Line Chart with Axis Tooltips

This example shows a line chart of Google stock data, tracking daily closing prices over time. It uses a React-based SVG visualization with D3 scales for mapping data to coordinates. The chart features interactive axis tooltips that appear on mouse movement, displaying detailed date and price information. The code implements custom tooltip paths for both axes, uses d3.bisector for data lookup, and includes a multi-format time formatter for adaptive tick labels. The data source is a CSV file containing five years of historical stock data for GOOGL.

Apr 1, 2021

Line Chart with label V2

This line chart displays Google stock prices (open, high, low, close, and volume) over time from March 2016 to March 2021, using data loaded from a CSV via `d3.csv`. Built with React and d3.v5, the visualization uses `scaleTime` and `scaleLinear` for axes, and a `line` generator with `curveStep` to render the closing price trajectory. A crosshair cursor with `bisector` and `xScale.invert` enables interactive tooltips showing detailed values for each date.

Apr 1, 2021

Line Chart with label

A step-shaped line chart displays Google stock closing prices (GOOGL) from March 2016 to March 2021, with a hover tooltip showing the exact price and date. The visualization uses React with SVG rendering, relying on d3.scaleTime and d3.scaleLinear for axes, d3.line with curveStep for the path, and d3.bisector for nearest-point lookup. Interactive tooltips are implemented through React state and mouse events, while the multiFormat time axis adapts its tick labels based on date granularity. Data loads asynchronously via d3.csv from a remote gist.

Mar 31, 2021

Fork of Fork of Stylized Line Chart

This interactive line chart visualizes 20,000 synthetic temperature readings over time, rendered as SVG paths using D3’s `line` and `area` generators within a React framework. Users can brush horizontally to zoom into finer levels of detail, switching between area and line representations while tooltips display exact timestamps and values. The data is preprocessed into multiple levels of detail, reducing points per view to maintain performance. D3 scales (`scaleTime`, `scaleLinear`) and axis components handle the coordinate system, with brush interactions powered by `brushX` and event listeners.

Mar 31, 2021

Fork of Stylized Line Chart

This visualization displays a time series of temperature data, rendered as a line chart that switches between a refined line and a filled area representation. Built with React and D3 v5, it uses `d3.scaleLinear` and `d3.scaleTime` to map data to SVG coordinates, with `d3.area` for the area chart. Users can brush horizontally to zoom into the data, which triggers a level-of-detail reduction that switches between raw data points and aggregated min/max ranges, with circles drawn at high zoom levels.

Mar 30, 2021

Stylized Line Chart

This stylized line chart visualizes temperature fluctuations over a week in San Francisco, using a smooth natural curve to connect data points from the Data Canvas Sense Your City dataset. The SVG rendering leverages React components, with D3’s `scaleTime` and `scaleLinear` for axes, and `line` with `curveNatural` for the path. Styling via the Poppins font and muted colors gives the chart a clean, modern aesthetic, while tick marks and labels are generated through custom `AxisBottom` and `AxisLeft` components.

Mar 30, 2021

Multiple Views with Brushing

This example demonstrates linked brushing between a world bubble map and a time-series histogram, both rendered as SVG in React. The map plots migrant deaths and missing persons by location with circle radii scaled by d3.scaleSqrt, while the histogram aggregates the same metric monthly using d3.bin and d3.timeMonths. Brushing the histogram with d3.brushX filters the map’s displayed circles in real time. The visualization uses d3.geoNaturalEarth1 and d3.geoPath for the map projection, and loads data from a CSV of the Missing Migrants Global 2019 subset.

Multiple Views Cleanup

This interactive visualization combines a world map with a time-series histogram to explore missing migrant data across the globe. The map uses a natural Earth projection with `d3.geoPath`, plotting circles scaled by the square root of the "Total Dead and Missing" counts. The histogram below, built with `d3.bin` and `d3.scaleTime`, aggregates these counts by reported month. Both views render as SVG within a React framework, with the data sourced from a Missing Migrants project CSV file.

Missing Migrants on a Map

A world map rendered with D3's geoNaturalEarth1 projection places semi-transparent circles at locations of documented migrant deaths and disappearances. Circle size encodes the total dead and missing count from the Missing Migrants Global 2019 dataset. The visualization uses React components, with d3.geoPath for landmasses, graticules, and interiors from TopoJSON, and d3.scaleSqrt to map the aggregated values.

Fork of Working with Time

This histogram displays the total number of dead and missing migrants over time, with monthly bins aggregated from the Data Canvas Sense Your City dataset. The visualization uses React components for the axes and marks, with d3.scaleTime and d3.scaleLinear for scales. The data is loaded via d3.csv and processed using d3.histogram, d3.timeMonths, and d3.sum to create the bar chart rendered as SVG rectangles.

Points on a Map

A world map displays cities as semi-transparent, radius-scaled circles proportional to population, using a Natural Earth projection. The visualization, built with React and D3 (v5), renders SVG paths for land, graticules, and sphere outlines via `geoPath`, while circles are projected using `geoNaturalEarth1`. City data comes from a CSV of world cities, and the map’s geographic basemap is provided by the `world-atlas` TopoJSON, processed through `topojson.feature` and `topojson.mesh`.

Interactive Color Legend

This scatter plot visualizes the Iris Dataset, showing petal length against sepal width, with points colored by species. The visualization includes an interactive color legend on the right that allows users to highlight specific species by hovering over the legend items. When a legend item is hovered, the corresponding species’ points remain at full opacity while all other points fade to 20% opacity. The chart is built using React with D3 scales (`d3.scaleLinear`, `d3.scaleOrdinal`), rendered as SVG, and includes custom axis components for tick marks and labels.

Scatter Plot with Color Legend

A scatter plot of the Iris Dataset displays four numeric attributes on selectable X and Y axes, with points colored by species via an ordinal color scale and a legend. Using D3 v5 scales (scaleLinear, scaleOrdinal), the React application renders SVG axes, marks, and dropdown menus. Users select attributes from menus, and hover tooltips reveal values. The dataset is loaded from a CSV URL using D3's csv parser.

Scatter Plot with Color

Interactive scatter plot of the Iris dataset using React, D3 v5, and SVG, which visualizes relationships between sepal and petal measurements. Users can switch the X and Y axes via dropdown menus to explore different attribute combinations. A categorical color scale (`d3.scaleOrdinal`) distinguishes the three iris species, with `d3.scaleLinear` mapping numeric coordinates. The plot includes formatted axes and tooltips showing values on hover.

Stylized Scatter Plot

This interactive scatter plot visualizes the Iris Dataset, allowing users to explore relationships between sepal and petal measurements by selecting different attributes for the X and Y axes via dropdown menus. The visualization uses React with d3.scaleLinear for axes and d3.extent to compute domains, rendering circles as SVG marks with tooltips. Styling employs the Poppins font and custom tick colors, while data loading relies on d3.csv to parse the remote iris.csv file.

Scatter Plot with Menus

A scatter plot of the Iris Dataset displays sepal and petal measurements, with dropdown menus allowing users to select which attributes appear on the x- and y-axes. The visualization uses React with D3's `scaleLinear` and `extent` to map data to SVG circles, while axes are rendered via custom `AxisBottom` and `AxisLeft` components. The dropdowns update state to re-scale and re-render the marks dynamically, with formatted tick labels using D3's `format`.

Menus with React

This example shows a pet-selection menu built as a React component, demonstrating how to manage and update a dropdown’s state. The `Dropdown` component renders a native `<select>` element, mapping an array of pet options into `<option>` tags. The main `App` component uses React’s `useState` hook to track the selected value, initially set to “goldfish,” and passes both the current value and an `onSelectedValueChange` callback to update it on user interaction. The UI is styled with large labels and select text, and the example runs in a browser using ReactDOM to mount the app.

World Map

A world map rendered in SVG using the D3 geoNaturalEarth1 projection, with graticules and country borders. The visualization displays land masses in teal against a light gray sphere, using data from the world-atlas TopoJSON dataset. The React component loads the data via D3's json function and applies topojson feature and mesh operations. A d3.geoPath generator traces the projected land, interiors, and graticule paths.

Stylized Scatter Plot

A scatter plot displays the Iris Dataset, plotting petal length against sepal width with a circular mark for each sample. The visualization uses React components to render SVG elements, with d3.scaleLinear for axes scaling and d3.extent for domain calculation. Axes are custom-built components using SVG lines and text, styled with the Poppins font. Data is loaded asynchronously via d3.csv and transformed with numeric type coercion, while tooltips appear on hover through SVG title elements.

Bar Chart v2

A vertical bar chart displays the populations of ten countries in 2020, sourced from a UN population CSV loaded with `d3.csv`. The x-axis labels are rotated 30 degrees to accommodate country names, and the y-axis uses a custom tick formatter that abbreviates billions as "B". Built with React and SVG, the chart uses `d3.scaleBand` for the categorical axis and `d3.scaleLinear` for the continuous population scale, with tooltips generated via SVG `<title>` elements.

Stylized Bar Chart

This stylized bar chart ranks ten countries by their 2020 population estimates from the UN Population dataset, with horizontal bars positioned by a d3.scaleBand and sized by a d3.scaleLinear. Each bar includes a native SVG `<title>` tooltip showing the formatted value, and the y-axis lists country names while the x-axis applies a custom tick formatter that converts units from "G" to "B". The visualization is built with React, rendered as SVG, and styled with the Poppins font for a clean, modern look.

Refactored Bar Chart

This example shows a horizontal bar chart of the top ten countries by 2020 population, sourced from a CSV file of UN population data. The chart uses React components to render the visualization as SVG, with d3-scale for the `scaleBand` y-axis and `scaleLinear` x-axis positioning. Population values drive bar widths, while country names label the left axis. The code is refactored into separate, reusable components for the axes and marks, with data loading handled by a custom `useData` hook that uses d3.csv.

Axes with React & D3

This example shows a horizontal bar chart of the top 10 countries by 2020 population, with axes drawn entirely through React components and D3 scales. The code uses `scaleBand` and `scaleLinear` to map country names and population values to pixel coordinates, while manually rendering tick marks and labels for both axes as SVG elements. Data is loaded from a CSV file using `d3.csv`, and the chart updates reactively through React’s `useState` and `useEffect` hooks.

The Margin Convention

This example demonstrates the margin convention in a bar chart, showing population data for the top 10 countries from the UN Population 2019 dataset. A `<g>` element is translated by the margin values, with the inner plotting area calculated separately for the x and y scales. It uses React with `useState` and `useEffect` to load data via `d3.csv`, then renders SVG rectangles positioned by `d3.scaleBand` and `d3.scaleLinear` on an SVG canvas. The chart displays horizontal bars without axes or labels, focusing on the layout offset technique.

Pathetic Bar Chart

This example displays the top 10 most populous countries as horizontal bars, using a United Nations population dataset loaded via `d3.csv`. The bars render in SVG, with `d3.scaleBand` positioning each country along the y-axis and `d3.scaleLinear` mapping population values to bar widths on the x-axis. React manages the data state and renders each rectangle, while D3 handles the scaling and data parsing.

Rendering Data with React & D3

This example visualizes CSS named colors as a radial burst of pie slices, each filled with its corresponding RGB hex value. It loads the dataset from a CSV via D3’s `csv` utility, then uses React to render an SVG containing a path for every color, positioned with `d3.pie` and `d3.arc` to compute slice geometry. The visualization highlights the distribution of named colors around a central point.

Rendering Data with React & D3

This example displays 148 CSS named colors as a vertical striped column, where each stripe's height and color correspond to a row in a CSV dataset loaded from a Gist. The visualization uses D3’s `csv` function to fetch and parse the data, then React's `useEffect` and `useState` hooks manage the asynchronous loading and rendering. Each color is drawn as a `<div>` element with its background set to the hex value parsed from the dataset, producing a simple, sequential swatch layout.

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 visualization fetches a CSV file of CSS named colors via `d3.csv` and manages the asynchronous result with React’s `useState` and `useEffect` hooks. Once loaded, the data is formatted using `d3.csvFormat` to compute its size in kilobytes, while React renders the resulting text statistics as SVG content.

Vega-Lite API Template

This example shows a scatterplot of firearm background check permits over time, using data from a BuzzFeed News CSV file. Each circle marks a monthly observation, with points semi-transparent to reveal overlapping values along the time axis. The visualization is built with the Vega-Lite API, which wraps Vega and Vega-Lite, and relies on D3’s `csv` loader for data ingestion. Rendering uses an SVG view with a custom configuration for axis styling and font sizes, and tooltips are enabled via Vega Tooltip’s `Handler`. The code draws on the `vl.markCircle`, `vl.x`, `vl.y`, and `vl.tooltip` methods to define the encoding, with a fixed size and opacity.

Loading and Parsing CSV Data

This example shows a minimal text summary of a CSS named colors dataset, reporting its size in kilobytes, row count, and column count. It demonstrates CSV loading and parsing with D3’s `d3.csv` method, which fetches the remote gist file and returns a parsed data array. The code also computes the formatted CSV string via `d3.csvFormat` to calculate the file size, and uses `data.columns` to display the number of columns. A commented alternative using `fetch`, `await`, and `d3.csvParse` is also present.

Mouse Follower

A circle follows the mouse cursor across an SVG canvas, with its position updating in real time to mirror the pointer’s coordinates. The example uses React state and a `useCallback` event handler to capture mouse movements and re-render the circle’s `cx` and `cy` attributes. Rendered as an SVG element via ReactDOM, the visualization demonstrates a simple interactive binding between user input and graphical output, leveraging D3 v5 only for the underlying scripting environment.

Loading Data with Fetch

This example demonstrates how to load external data in the browser using the Fetch API. The page displays a static “Hello HTML” message while the script fetches a CSV file of named CSS colors from a GitHub gist, logging the raw text response to the browser’s console. It uses `fetch()` with async/await syntax, assigning the asynchronous function to `fetchText`, and chains a `.then()` callback to log the result. No visualization is rendered; the focus is purely on the data-loading workflow.

Smiley Face Part I

The example shows a grid of 18 randomly generated smiley faces, each rendered as a separate SVG element using React components. It demonstrates how D3’s `arc` API, imported from the `d3` library, constructs the mouth path, while React’s component-based structure modularizes the face into reusable parts like `BackgroundCircle`, `Eyes`, and `Mouth`. The `range` function from D3 generates the array of faces, and each face’s properties—such as stroke width, eye offset, and mouth radius—are randomized per instance, producing varied expressions.