liu yang

@Lliuduanduan·25 public vizzes

Fork of D3 Selection Exploration

Animated sine-generated circle sequences flow across the canvas, with horizontal position fixed and vertical position and radius oscillating sinusoidally over time. The visualization demonstrates D3's selection and join API. Using D3 v7.8, the code updates at 60 FPS via `setInterval`, calling a `vizData` function that employs the `.join()` operator to merge entering and exiting SVG circles with animated attributes.

Aug 13, 2024

Loading thumbnail…

Fork of Bar chart with a Sequential color scale

This bar chart displays the average horsepower of car makes, sorted from lowest to highest, with a sequential color scale from light to dark red indicating increasing values. It uses D3 v6 with SVG rendering and includes interactive tooltips on hover, as well as axis labels and a legend. The code employs `d3.scaleBand` for the x-axis, `d3.scaleLinear` for the y-axis, and `d3.scaleQuantize` with `colorbrewer.Reds[7]` for the color mapping. Data is loaded from a CSV file and filtered to seven specific makes.

Mar 1, 2024

Loading thumbnail…

Table test

This example displays a scatter plot of dialog data from a CSV file, cycling through different column pairs every three seconds. It uses D3’s `csv` loader and `scaleLinear`, `axisLeft`, and `axisBottom` to render circles and axes. The animation is driven by `setInterval`, which updates the x-value mapping, while the SVG and WebGL rendering show the full-screen visualization. The data includes character utterances with numeric attributes like sepal measurements, though the columns are re-assigned dynamically.

Nov 28, 2023

Loading thumbnail…

Animated Scatter Plot with Menus

This animated scatter plot visualizes the Iris dataset, letting users explore relationships between sepal and petal measurements through two dropdown menus that dynamically reassign the x and y axes. The visualization uses D3.js version 7 to render SVG circles with smooth transitions, animating point positions and radii when axis selections change. The scatterPlot module implements d3.scaleLinear scales, axisBottom and axisLeft components for axes, and uses transition objects with 1000ms duration for coordinated circle movements and axis updates.

Nov 28, 2023

Loading thumbnail…

Animated Reusable D3 Scatter Plot

This example visualizes the classic Iris flower dataset as a scatter plot that cycles through different variable pairings every three seconds. Each circle represents a flower, with its position mapped to the selected x and y axes, and points animate smoothly to their new locations. The visualization uses D3 v7’s reusable module pattern, with `scaleLinear`, `axisLeft`, `axisBottom`, and `transition` to handle the animated updates of both circles and axes. The x-value changes among four measurement columns, while the y-value remains fixed, highlighting correlations between sepal and petal dimensions.

Nov 26, 2023

Loading thumbnail…

Reusable D3 Scatter Plot

This interactive scatter plot visualizes the Iris dataset, cycling through different combinations of petal width and sepal length every three seconds. Using the D3.js library, it employs a declarative, reusable `scatterPlot` component that leverages `scaleLinear`, `extent`, `axisLeft`, and `axisBottom` APIs. The SVG visualization dynamically updates its x-value mapping, animating through the dataset columns while rendering circles and labeled axes with a fixed margin and radius. Data is loaded asynchronously from a remote CSV via `d3.csv`.

Nov 25, 2023

Loading thumbnail…

Reusable D3 Scatter Plot with symbols

This example demonstrates a reusable scatter plot implemented with D3 v7, visualizing the classic Iris dataset by mapping petal width and sepal length along the axes. The plot distinguishes the three Iris species using different SVG symbols, generated through `d3.symbol` and `d3.symbols`, with positions scaled by `d3.scaleLinear` and axes drawn via `d3.axisLeft` and `d3.axisBottom`. The chart is built as a custom function that accepts configurable width, height, margins, and accessor functions, and renders SVG elements after loading data asynchronously with `d3.csv`.

Nov 23, 2023

Loading thumbnail…

Fork of Title to the Dot (Studying of D3 Scatter Plot)

This example visualizes the Iris dataset as a scatter plot, mapping petal length on the x-axis against sepal length on the y-axis. Each circle represents a flower sample, with a hover tooltip showing the exact coordinates. Built with D3 v6, the code loads CSV data, uses `scaleLinear` and `extent` to set scales, and renders circles as SVG elements. Axes are added via `axisLeft` and `axisBottom`, with the chart sized to the full browser window.

Nov 20, 2023

Loading thumbnail…

D3 Scatter Plot

This example visualizes the classic Iris dataset as a scatter plot, mapping petal width to the x-axis and sepal length to the y-axis. Circles represent individual flowers, with axes labeled via D3’s `scaleLinear`, `axisLeft`, and `axisBottom` APIs. The code loads CSV data using `d3.csv`, parses numerical fields, and renders the plot as SVG circles sized with a fixed radius. The visualization fills the browser window, using viewport dimensions for the chart’s width and height, and demonstrates a straightforward data-joining workflow with `selectAll` and `join`.

Nov 19, 2023

Loading thumbnail…

D3 Selection Exploration

This example demonstrates D3’s data join and update pattern with animated circles. A sine wave controls the number and vertical position of circles, which are appended using the `selection.join` method. The animation runs on a 60-frame interval, updating circle `cx` and `cy` attributes. It uses d3.v7, with SVG rendering, to show enter, update, and exit handling as data changes over time.

Nov 15, 2023

Loading thumbnail…

test

This example shows two overlapping black-outlined circles on an empty white field, creating a simple Venn-like intersection. The shapes are drawn using raw SVG `<circle>` elements within an HTML5 document, with no external JavaScript or styling libraries. Each circle has a fixed radius of 50 pixels and a stroke-only fill, positioned at distinct coordinates to demonstrate basic geometric overlap in a static, hand-coded visualization. The rendering is handled entirely by the browser's native SVG support, with no data source or interactive behavior involved.

Nov 15, 2023

Loading thumbnail…

SVG Fundamentals

This example demonstrates basic SVG shape rendering through a static canvas containing a solid circle and an open polyline path. The visualization shows how SVG primitives construct simple geometric forms without any interaction or animation. The code directly embeds SVG elements in HTML, using a `<circle>` element for the filled shape and a `<path>` element with explicit coordinates and stroke styling for the line. The rendering relies on the native SVG API, with no external JavaScript libraries or data processing involved.

Nov 15, 2023

Loading thumbnail…

JS in HTML

This example demonstrates a minimal integration of D3.js within an HTML page, displaying the static text “Hello HTML!” alongside a CSS-styled message placeholder. The code imports the `select` function from D3 and a custom `something` string from a local module, logging both to the console without rendering any data-driven visualization. It relies on D3 v7.8.5 loaded via a CDN link, with plain HTML structure and inline styling. The example illustrates basic JavaScript module imports and console output rather than visual data mapping.

Nov 13, 2023

Loading thumbnail…

JavaScript Arrays

This example demonstrates JavaScript array manipulation methods and how D3.js integrates with them. It shows a hardcoded array of numbers from 0 to 9 and an array of key-value objects, with the latter being sorted alphabetically by key using the `ascending` comparator from D3. The page displays the title "JavaScript Arrays" in large centered text, while the actual array operations—such as `map`, `reduce`, and `sort`—are executed in the console with commented-out examples for reference. The code relies solely on D3’s `ascending` function for sorting and does not render any visual chart or graphic.

Nov 12, 2023

Loading thumbnail…

Fork of Fork of Full Sol LeWitt Reproduction with D3

This visualization recreates a Sol LeWitt wall drawing using an SVG canvas. It layers two sets of perpendicular, striped rectangles, each masked to reveal the artwork through repeating geometric symbols. The code uses D3 v7 methods like `select`, `range`, `join`, and `symbol` to generate the marks. Two SVG masks are applied with inverted fills, producing a crosshatched pattern where the symbols appear as cutouts.

Nov 11, 2023

Loading thumbnail…

Fork of Full Sol LeWitt Reproduction with D3

A fork of the Sol LeWitt wall drawing reproduction renders a grid of horizontal and vertical stripes, each masked by a circular form, on an SVG canvas that fills the browser window. The piece uses the D3.js API, specifically `select`, `range`, and the `join` method, to generate the stripes, while masks are created with `symbol` and `symbols` to imprint the circle. The result is a geometric interplay of lines and negative space, driven entirely by D3's declarative data-binding and SVG rendering.

Nov 11, 2023

Loading thumbnail…

Full Sol LeWitt Reproduction with D3

This example reproduces a Sol LeWitt-style drawing using overlapping horizontal and vertical striped rectangles, masked to reveal a white diamond shape at the center and a black circle behind it. The visualization is rendered as an SVG using D3 v7, leveraging `select`, `range`, `join`, and `symbol` APIs to generate the grid of lines. Two masks (`circle-mask` and `circle-mask2`) combine the shapes, with the horizontal bars visible through the diamond and vertical bars elsewhere. The code imports from `d3` and appends elements to the body, adapting to the full window size.

Nov 11, 2023

Loading thumbnail…

Fork of Full Sol LeWitt Reproduction with D3

This example generates a full-screen grid of thin horizontal and vertical stripes, using SVG masks to create a circular cutout at the center revealing a solid white disk. The stripes are rendered as individual SVG `rect` elements within two groups, with each group masked by a radial shape. The code uses the D3.js library’s `select`, `range`, and `symbol` functions, along with symbol paths to produce the mask geometry. The layout is derived from the browser’s viewport dimensions, making the visualization responsive to the window size.

Nov 10, 2023

Loading thumbnail…

Fork of Sol LeWitt Reproduction with D3

This visualization recreates a Sol LeWitt-inspired geometric composition using two overlapping grids of vertical and horizontal bars. The bars are partially revealed through circular masks, creating a cross-shaped aperture effect at the center of the canvas. The code uses D3 v7’s `select`, `range`, and `join` methods to generate SVG rectangles, with two `mask` elements defining the visible circular regions. The artwork spans the full browser window and renders entirely as SVG, with all positioning computed dynamically from `window.innerWidth` and `window.innerHeight`.

Nov 10, 2023

Loading thumbnail…

Sol LeWitt Reproduction with D3

This example recreates a Sol LeWitt wall drawing using D3.js, rendering a grid of horizontal and vertical rectangles in SVG. Two circular masks are applied to show only the overlapping region where the lines intersect. The code uses d3.select and d3.range to generate 100 bars in each direction, with the masks defined as SVG elements that hide or reveal portions of the grid. The artwork fills the entire browser window, displaying only the masked circular intersection.

Nov 10, 2023

Loading thumbnail…

Fork of Sol LeWitt Reproduction vertical

A generative drawing builds a vertical grid of thin horizontal and vertical bars that intersect inside a central circular aperture. Two SVG masks define the visible region: one mask reveals a black-circle-on-white-background pattern for the horizontal bars, while the inverse mask displays the vertical bars against a black circle. The composition uses 100 stacked rectangles for each orientation, created with the Document Object Model’s `createElementNS` and `setAttribute` methods. This fork of a Sol LeWitt reproduction inverts the horizontal mask’s fill color, altering the interplay of line weights.

Nov 9, 2023

Loading thumbnail…

Sol LeWitt Reproduction vertical

This is a generative SVG reproduction of Sol LeWitt’s wall drawing, shown vertically across the full browser viewport. A circular mask, defined via SVG `<mask>` and a white circle, reveals only the central region of a grid of 100 horizontal and 100 vertical black rects. The horizontal rects are layered beneath the vertical ones and clipped by the mask, creating a contrasting circular window. The piece uses raw JavaScript DOM manipulation with `document.createElementNS` to build the SVG elements dynamically, with no external libraries.

Nov 9, 2023

Loading thumbnail…

Sol LeWitt Reproduction

This example reproduces a Sol LeWitt–style drawing as a full-screen grid of vertical black rectangles. One hundred narrow SVG `rect` elements are laid out side by side, each ten pixels wide and spaced twenty pixels apart, creating a rhythmic, minimalist composition. The script generates the SVG dynamically using the DOM API `document.createElementNS` and appends it to the body, with dimensions matching the browser window. The rendering is purely procedural, with no external libraries or data sources.

Nov 9, 2023

Loading thumbnail…

javascript basics

This example reproduces a Sol LeWitt-style drawing using an SVG canvas. The page sets up a 960-by-500-pixel `<svg>` element and uses JavaScript to define and log a `person` function that returns an object with `first` and `last` properties. The code demonstrates basic arrow-function syntax and object shorthand, though no visual output is generated beyond the empty SVG container.

Nov 9, 2023

Loading thumbnail…

pseudo Scatter Plot

This example presents a hand-coded, minimal approximation of a scatter plot. It shows two graphical marks on a blank SVG canvas: a solid black circle and a thick black polyline. The visualization does not use a charting library but relies on raw SVG elements written directly in HTML. The circle is positioned using its center coordinates and radius, while the polyline is defined by a series of absolute coordinates in the path’s `d` attribute. The rendering surface is an SVG viewport with a fixed width and height, and no data file or external dataset is referenced.

Nov 6, 2023