C

Cheng Tang

@ChengTang62·38 public vizzes

Loading thumbnail…

Fork of Interactive Color Legend

This interactive scatter plot visualizes the Iris dataset, mapping petal length against sepal width, with each point colored by species. Hovering over a species in the color legend highlights only points of that species by increasing their opacity while dimming others. The visualization uses React with D3 scales, including `d3.scaleLinear` for axes and `d3.scaleOrdinal` for colors. It fetches data via `d3.csv` and renders all marks and the legend as SVG circles.

Loading thumbnail…

Fork of Migrant Deaths Linked Views with Fast Brushing

This interactive visualization displays migrant deaths and disappearances worldwide, combining a bubble map with a brushing-linked time series histogram. The map projects incident locations using `d3.geoNaturalEarth1` and `d3.geoPath`, with circle areas scaled by death counts. A brushable date histogram built with `d3.brushX` and `d3.bin` filters the map’s bubbles in real time. React hooks like `useMemo` optimize rendering performance, while data comes from the Missing Migrants Project CSV and world boundaries from World Atlas TopoJSON.

Loading thumbnail…

Fork of Stylized Line Chart

This fork of a stylized line chart displays temperature over time for a week in San Francisco, using a smooth natural curve rendered as a filled SVG area. The visualization relies on React for component structure and D3 v5 scales (scaleTime, scaleLinear) and shapes (area, curveNatural) to map data. Axes are built with custom React components using D3’s scale ticks. The dataset is loaded as CSV from a GitHub gist via d3.csv.

Loading thumbnail…

Fork of Time Series: Part 2 - Line Chart

This line chart displays weekly temperature variations in San Francisco, plotting time on the x-axis against temperature on the y-axis using d3.scaleTime and d3.scaleLinear. The React-based visualization renders SVG axes with custom tick formatting via timeFormat, while data loads asynchronously from a CSV dataset through d3.csv. Empty axes and labels are shown, with the loading state indicated by a pre element.

Loading thumbnail…

Fork of Coronavirus Linear Y Axis

This line chart displays the cumulative total of COVID-19 deaths over time using a linear y-axis scale. It fetches data from the Johns Hopkins Coronavirus time-series dataset via `d3.csv` and aggregates daily death totals. The chart is rendered with React (version 16.9) and SVG, using `d3.scaleTime`, `d3.scaleLinear`, `d3.axisBottom`, and `d3.axisLeft`. Gridlines are drawn by setting `tickSize` on the axes, and the chart fills the entire browser window, updating responsively.

Loading thumbnail…

Fork of D3 Starter

This example demonstrates a minimal D3 version 7 starter template that renders the text "Hello D3 version 7" centered on a blank page using the `d3.select()` API. The page loads D3 from a CDN and runs a JavaScript bundle that calls `select('body').text(...)`. It also includes an unused dropdown menu component built with React, referencing sensor data options, though it does not affect the displayed visualization. The primary rendering relies solely on D3’s DOM selection and text manipulation.

Loading thumbnail…

Fork of Menus with React

This example demonstrates an interactive dropdown menu built with React, letting users select a pet from a list of six options. It uses the `useState` hook to track the currently selected value and the `Dropdown` component, which renders an HTML `<select>` element whose options map over a hardcoded array of animal choices. The selected value is passed back via an `onSelectedValueChange` callback, and the selection is logged to the console. The app mounts with `ReactDOM.render` and includes custom styling for large label and select text.

Loading thumbnail…

Fork of Fork of React Starter

A React login page displays a numerical keypad and input fields, framed by an empty SVG canvas and a car image. The interface uses React and ReactDOM to render the UI, with the keypad featuring clickable buttons, although the code does not implement any interaction logic. The page includes labels and a login button, all drawn with standard HTML elements and an inline SVG tag.

Loading thumbnail…

Fork of React Starter

This example displays a centered, large-scale "Hello React!" message on a plain webpage. It uses React and ReactDOM to render a single component, `App`, into the `#root` div. The component is defined with a `className` of "message", which is styled with a font-size of 13em and centered text. The code imports React and ReactDOM directly and calls `ReactDOM.render` to mount the static text. The page loads React via CDN and runs the component output through a bundled JavaScript file.

Loading thumbnail…

Fork of React Starter

This example renders a minimal React application that displays a single large, centered message. The code uses React 16.13.1 with hooks like `useState` and `useEffect` imported but not yet utilized, alongside `ReactDOM.createRoot` for mounting. The styling applies a 13em font size to the `.message` class within an HTML page that loads React from a CDN. The app currently returns an empty component, so no data or visual content is shown beyond the blank root element.

Loading thumbnail…

Fork of HTML Starter

This visualization presents an interactive dashboard for exploring environmental sensor data. It renders a world map alongside line charts and a contour map, allowing users to select different sensor attributes from a dropdown menu. The code uses React with hooks, D3 scales and time parsing, and SVG rendering. Data is fetched from a local API endpoint, with brushed time ranges filtering the displayed temporal and spatial patterns.

Loading thumbnail…

Untitled

This example presents a smart locker management interface, simulating a login and package pickup workflow. After authentication, users enter a six-digit code via a custom on-screen keyboard, and the submission triggers a request to a backend API. The React-based application uses Axios to handle HTTP POST requests for login and order pickup, while conditional rendering manages the display of the login page, the alphanumeric keypad, and a Material UI dialog for status alerts. An empty SVG canvas is included, though no visual data is rendered.

Loading thumbnail…

Fork of C4SAM Services

This interactive D3 tree diagram visualizes a hierarchical dataset of hip replacement services, organizing experts by institution, city, and country. The visualization fetches CSV data from a GitHub gist and uses `d3.csv` to load it, then constructs a nested tree structure through successive filtering and sorting operations. The rendering uses `d3.hierarchy` and `d3.linkHorizontal` to draw the branching layout, with SVG output that responds to the window size. The animation is triggered by node interactions, though the specific transitions are not detailed in the visible code.

Loading thumbnail…

Fork of React & D3 Starter

This visualization maps reported emotions onto a two-dimensional space using x and y coordinates, with each emotion rendered as a point. The code uses React's `useData` hook to load data from a CSV, and D3.js `scaleLinear` scales to position the points. A density contour overlay, created with `d3.contourDensity()` and `d3.geoPath()`, highlights clusters of emotions, colored with a custom `d3.scaleLinear` color scale. The visualization leverages D3's axes module for gridlines and margins within an SVG rendered by React.

Loading thumbnail…

Fork of Fork of React & D3 Starter

This example demonstrates a React and D3 starter template for building scalable data visualizations with decoupled integration. It displays a scatterplot of flower measurements from the classic Iris dataset, mapping sepal length to the x-axis and petal length to the y-axis using `d3.scaleLinear` and `d3.extent`. Circles represent individual data points, with axes generated via `d3.axisLeft` and `d3.axisBottom`. The visualization uses React versions 18.1.0 and D3 version 7.4.4, rendering in SVG. The architecture separates React components from D3 logic, showcasing patterns for handling complexity as projects grow.

Loading thumbnail…

Fork of React & D3 Starter

This example shows a scatter plot of the Iris dataset, mapping sepal length to the x-axis and petal length to the y-axis, with each circle representing a flower sample. The visualization is built with React and D3 v7, using a custom `viz` function that creates linear scales via `d3.scaleLinear` and renders SVG circles with the data join pattern. Axes are added through `d3.axisLeft` and `d3.axisBottom` in a separate module. The code demonstrates a decoupled architecture where React manages the component lifecycle and D3 handles the drawing logic, with data loaded asynchronously via `d3.csv`.

Loading thumbnail…

Fork of React & D3 Starter

This visualization presents a scatter plot of emotional states, with each point positioned by x and y coordinates derived from survey responses. The chart encodes user-reported emotions like "Desire," "Enthusiastic," and "Loved" in a 2D space, likely representing dimensions of emotional valence and arousal. Built with React and D3 v7, the code uses a `useData` hook to load CSV data and a `viz` function that constructs an SVG via D3's selection API. The project demonstrates a decoupled React-D3 integration pattern, where the `VizWrapper` component manages the SVG element and invokes the D3 rendering logic through a ref.

Loading thumbnail…

Fork of HTML Starter

This example demonstrates a minimal HTML page that displays the text "Hello HTML!" centered on the screen with a large font size. The page uses plain HTML for structure, CSS for styling the message class with a 13em font size and text alignment, and JavaScript is included but not actively used in the code. It serves as a basic starter template for HTML, CSS, and JavaScript projects.

Loading thumbnail…

Fork of Choropleth Map

This choropleth map colors world countries by their economy classification using a categorical ordinal color scale with the spectral scheme. The visualization renders geographic boundaries with `d3.geoPath` and the Natural Earth projection, loading TopoJSON and TSV data from the world-atlas package. Interactive zoom and tooltip features are commented out, leaving a static map with an optional color legend component defined in a separate module.

Loading thumbnail…

Fork of Choropleth Map with Interactive Filtering

This interactive choropleth map displays world economies color-coded by category, with a legend that allows users to click on a category to filter the map's display. The visualization uses a D3.js geoNaturalEarth1 projection and geoPath to render country shapes, with a sequential color scale derived from d3.schemeSpectral. Data is loaded from World Atlas. Hovering a country reveals its name and economy type. Clicking a legend item dims non-matching countries and brightens those in the selected category.

Loading thumbnail…

Fork of Polished Scatter Plot with Menus

This interactive scatter plot displays the Iris dataset, with menus that let the user select which attributes map to the X and Y axes, dynamically updating the visualization. The plot renders 150 circles as SVG marks, using D3’s `scaleLinear` for axis scaling and `extent` for domain calculation, while React manages state for the chosen attributes. Axis ticks are generated by D3’s scale `ticks` method, and tooltips appear via SVG `<title>` elements. The data is loaded asynchronously with D3’s `csv` function from a GitHub-hosted CSV file.

Loading thumbnail…

Fork of Migrant Deaths Linked Views with Fast Brushing

This visualization combines a world bubble map and a time-series histogram to explore migrant deaths globally. The map uses a natural Earth projection with `d3.geoPath` and `d3.geoNaturalEarth1` to plot points sized by `scaleSqrt` based on the "Total Dead and Missing" value. A `d3.brushX` on the timeline filters the map’s circles in real time, while `useMemo` optimizes rendering. Data comes from the Missing Migrants Project CSV, with country boundaries from World Atlas TopoJSON.

Loading thumbnail…

Fork of Stylized Line Chart

This example visualizes a week of hourly temperature readings from San Francisco, plotting them as a smooth line chart with time on the x-axis and temperature on the y-axis. The chart uses React with SVG rendering, and d3-scale functions like scaleTime and scaleLinear to compute positions, while d3.line with curveNatural generates the curved path. Axes are built from custom React components that render tick marks and labels, and the data is loaded as CSV using d3.csv.

Loading thumbnail…

Fork of Migrant Deaths Linked Views with Fast Brushing

This interactive visualization combines a world map of migrant deaths with a linked time-series histogram. The map displays circles scaled by the total dead and missing, while the histogram bins the same data by reported date and supports brush selection to filter the map in real time. It uses D3 v5 for geographic projections, time binning, and brushing, with React managing the state and rendering SVG elements. The world map is based on the World Atlas TopoJSON, while migrant data is loaded from a CSV of the Missing Migrants Project.

Loading thumbnail…

World Map

This map visualizes the world using a Natural Earth projection, presenting landmasses in teal and a graticule grid over a light sphere. The visualization shows countries and their internal boundaries, with the sphere and graticule establishing the geographic context. Built with React and D3 v5, it uses the `geoNaturalEarth1` projection and `geoPath` to render the map, while the `topojson` library's `feature` and `mesh` functions process the data source from the `world-atlas` package. The rendering is done entirely in SVG.

Loading thumbnail…

Rendering data with React & D3

This example combines React with D3 to render a donut chart of CSS named colors. It loads data from a CSV file using `d3.csv` and displays each color as an equal-sized arc using `d3.pie` and `d3.arc`, with the fill set to the hex value from the dataset. React manages the component state and conditional rendering, showing a loading placeholder until the data arrives, then draws the SVG paths inside a centered `<g>` element. The visualization demonstrates a simple division of responsibilities where D3 handles data parsing and geometry while React handles the DOM updates.

Loading thumbnail…

Fork of Loading and Parsing CSV Data

This example demonstrates the basic mechanics of loading and parsing CSV data in D3. It fetches a dataset of CSS named colors from a GitHub gist and displays three summary statistics: file size in kilobytes, row count, and column count. The primary implementation uses D3 v5’s `d3.csv` method, which returns a promise, while commented alternatives show equivalent code using the Fetch API with `async`/`await` and `d3.csvParse`. The output is rendered as plain text inside a large `<pre>` element.

Loading thumbnail…

Fork of Loading and Parsing CSV Data

This example demonstrates the basic mechanics of loading and parsing CSV data in D3. It fetches a dataset of CSS named colors from a GitHub gist and displays three summary statistics: file size in kilobytes, row count, and column count. The primary implementation uses D3 v5’s `d3.csv` method, which returns a promise, while commented alternatives show equivalent code using the Fetch API with `async`/`await` and `d3.csvParse`. The output is rendered as plain text inside a large `<pre>` element.

Loading thumbnail…

Fork of Temperature in San Francisco Line Chart

This line chart displays a week of temperature data in San Francisco, using a smooth curved line to connect daily measurements. The visualization, titled “A Week in San Francisco,” plots temperature in degrees Celsius over time. The code uses D3 v5 APIs including `scaleTime`, `scaleLinear`, `axisBottom`, `axisLeft`, and `line` with `curveBasis` to render the SVG. Data is loaded from a CSV file provided by Data Canvas - Sense Your City, with a styled maroon line, grid lines, and labeled axes.

Loading thumbnail…

Fork of Vega-Lite API Template

This example uses the Vega-Lite API to render an interactive scatter plot of the Auto MPG dataset from the UCI Machine Learning Repository. The visualization maps miles per gallon on the x-axis, horsepower on the y-axis, and encodes the car’s origin in color and weight in point size, with tooltips showing the vehicle name. Built with d3.csv for data loading and vega-tooltip for hover details, all marks are drawn as circles with opacity. The chart’s appearance is customized via a Vega-Lite config object, adjusting axis styles and typography for readability.

Loading thumbnail…

Loading and Parsing CSV Data

This example demonstrates loading and parsing CSV data using D3. It fetches a CSV file containing CSS named colors from a GitHub gist and uses the `d3.csv()` function to parse it. The visualization displays the parsed dataset’s metrics in a large text format, showing the row count, column count, and file size in kilobytes, which is computed with `d3.csvFormat()`. The code also includes commented alternatives using `fetch()` and `d3.csvParse()` with async/await syntax.

Loading thumbnail…

Fork of Smiley Face Part II

This example displays a yellow smiley face centered on a full-screen SVG that adapts to the browser window’s dimensions. The face includes a circular head with a black outline, two eyes offset from the center, and a static, expressionless composition. Built with React and ReactDOM, the visualization uses an SVG `<circle>` elements to draw the head, eyes, and mouth, with a `<g>` transform to position the entire face relative to the viewport’s center. The code relies on React’s JSX syntax to structure the SVG markup dynamically.

Loading thumbnail…

Fork of D3 Starter

This example demonstrates the initial steps of using D3 version 7, beginning with loading and parsing CSV data from a remote URL. The code fetches a CSV file containing CSS named colors using JavaScript’s `fetch` API and logs the resulting text to the console. The visualization itself is minimal, displaying the page title and a large text prompt via inline CSS, with the `index.html` file linking the D3 library from a CDN. No actual charts or graphical output are generated, focusing instead on the foundational data-acquisition workflow.

Loading thumbnail…

Fork of HTML Starter

This example demonstrates the fundamental structure of an HTML page styled with CSS and enhanced with JavaScript. It showcases two distinct code snippets: one displays a simple "Hello HTML!" message with large, centered text, while the other fetches and logs the contents of a CSV file containing named CSS colors from a remote GitHub gist. The JavaScript uses the native `fetch` API within an async function to retrieve the text data and output it to the browser’s console.

Loading thumbnail…

Mouse Follower

A small circle tracks the mouse in real time across a full-window SVG canvas. The React component stores the pointer’s coordinates in state via `useState` and updates them on every `mousemove` event through `useCallback`. The circle’s `cx` and `cy` attributes are bound directly to the current mouse position, re-rendering on each movement. The example uses React 16.9 with `ReactDOM.render`, an SVG with inline event handling, and no external data source or animation library.

Loading thumbnail…

Loading and Parsing CSV Data

This example demonstrates loading and parsing CSV data from a remote source, with the raw text output sent to the browser console. It uses the Fetch API to asynchronously retrieve the CSV file containing CSS named colors from a GitHub gist. The code defines a custom `fetchText` helper that returns the response body as a string, then chains a `.then()` callback to log the parsed text. It also includes commented-out alternative code showing a nested promise approach for comparison.

Loading thumbnail…

Hello HTML

This example renders a grid of smiley faces using React components and D3’s arc generator. Each face consists of a yellow background circle, two black eyes, and a mouth drawn with `d3.arc()`, all composed inside an SVG via a shared `FaceContainer` that applies a translation transform. Fifty faces are generated with randomly varying eye radii, producing subtle visual differences. The code demonstrates component reuse, D3’s `arc` API for path generation, and React’s rendering of SVG elements.

Loading thumbnail…

Fork of HTML Starter

This example demonstrates a minimal HTML page that displays the text "Hello HTML!" centered on the screen with a large font size. The page uses plain HTML for structure, CSS for styling the message class with a 13em font size and text alignment, and JavaScript is included but not actively used in the code. It serves as a basic starter template for HTML, CSS, and JavaScript projects.