Skip to main content
Log in
M

maximus2581

@maximus2581·15 public vizzes

Loading thumbnail…

D3 Scatter Plot

This D3 scatter plot displays the relationship between petal length and sepal length for 150 iris flowers, with each circle positioned by scaled linear axes. It loads the Iris dataset from a CSV file using `d3.csv`, then applies `d3.scaleLinear` with domains from `d3.extent` and ranges based on the window dimensions. The SVG circles are rendered via `d3.select`, `selectAll`, and `join`, while `d3.axisLeft` and `d3.axisBottom` generate the tick marks and labels.

Jul 29, 2022
Loading thumbnail…

Fork of Reusable D3 Scatter Plot- ICE7

This animated scatter plot from D3 explores the Iris dataset, cycling through different feature combinations on the x-axis (petal width, sepal width, petal length, and sepal length) while the y-axis remains sepal length. Data points are colored by species (setosa, versicolor, virginica) and rendered as SVG circles with adjustable radii. The visualization uses D3’s `csv`, `scaleLinear`, `axisLeft`, `axisBottom`, and `select` APIs to load data, scale axes, and manage the SVG canvas. A `setInterval` timer triggers the x-axis changes, and a legend with colored dots identifies each species.

Jul 27, 2022
Loading thumbnail…

D3 Selection Exploration

This example demonstrates dynamic SVG circle placement driven by a time-based animation. As time progresses, a varying number of circles reposition along a sine wave, creating a smooth, oscillating pattern. The implementation uses the D3.js library, specifically the `select` API for DOM manipulation and the `join` method to efficiently manage circle creation and updates. The animation runs at 60 frames per second via `setInterval`, with coordinates calculated using trigonometric functions and rendered as animated SVG elements.

Jul 12, 2022
Loading thumbnail…

Fork of Full Sol Lewitt Reproduction with D3

This visualization creates a grid of horizontal and vertical bars across the full browser window, using SVG masks to reveal d3 symbols (shapes) from the d3-shape module. It uses the `select`, `range`, `symbols`, and `symbol` functions from D3 v6 to generate a striped pattern with four distinct symbol types as mask cutouts. The code renders 100 rectangles in each orientation, with two masks applied to alternate between light and dark shading on the revealed shapes. The rendering adapts to the window’s dimensions and uses `join` to bind data to SVG elements.

Jul 9, 2022
Loading thumbnail…

Fork of Sol LeWitt Reproduction with D3

This example reproduces a Sol LeWitt-style geometric composition using D3.js, generating an intricate grid of overlapping horizontal and vertical bars. The visualization uses two mask layers to create alternating colored regions, with the second mask inverted to produce a dynamic contrast pattern. Rendered as SVG, the code employs D3's `scaleBand`, `range`, `symbol`, and `symbols` APIs to position and shape the elements, while `join` manages the data-driven rect and path creation. Layout adapts to the browser window size, with 120 bands across the full viewport.

Jul 9, 2022
Loading thumbnail…

Full Sol Lewitt Reproduction with D3

This visualization reproduces a Sol LeWitt wall drawing using D3.js, rendering a grid of horizontal and vertical lines that are selectively masked by circular paths. The piece uses D3’s `select`, `range`, and `symbol` APIs to create 100 rectangles in each orientation, with the masks defined via SVG `mask` elements and D3’s path symbols. The full-viewport SVG canvas adapts to the browser window, and the `join` operation efficiently appends the graphical primitives.

Jul 7, 2022
Loading thumbnail…

Fork of Sol Lewitt Reproduction with D3

This example reproduces a Sol LeWitt-inspired drawing using overlaid horizontal and vertical stripes, each masked by a circle at the center. The composition reveals a square grid of lines intersecting within a circular boundary against a contrasting background. The visualization uses the D3.js library (v6.6.1) through a React interface, rendering SVG elements via the `select`, `range`, and `append` APIs. It constructs masks with `attr` to define the circular cutouts, and generates the 100 stripes per direction using D3's `join` for efficient data-driven element creation.

Jul 6, 2022
Loading thumbnail…

Sol Lewitt Reproduction SVG

This example reproduces a Sol LeWitt-style geometric drawing using SVG, showing a grid of horizontal and vertical stripes that are masked to reveal a central circle. The visualization dynamically fills the browser window by setting the SVG width and height to the viewport dimensions. It constructs two SVG masks with white and black circles and rectangles, then renders 100 horizontal and 100 vertical stripe rectangles, each referencing a mask to clip the pattern. The code uses the DOM API `document.createElementNS` to build SVG elements programmatically with JavaScript.

Jul 4, 2022
Loading thumbnail…

Let's make a face

A yellow circle with black outlined eyes forms a simple face, with a curved mouth drawn as an arc. The visualization uses D3 v6 selections to append SVG circles for the face and eyes, and an SVG path for the mouth. The `arc` generator from D3 creates the mouth’s semicircular shape, positioned using explicit pixel coordinates for the eyes and a translation for the mouth group. All elements are rendered directly onto an SVG canvas with fixed dimensions.

Jan 12, 2021
Loading thumbnail…

Cars Report

This example shows a simple text-based report of car listings filtered by price. It demonstrates asynchronous data fetching with a mock API using JavaScript Promises, and modular code organization with ES6 exports and imports. The `getCars` function simulates a two-second delay before returning parsed JSON car data, while `generateReport` filters cars under a specified price and formats each entry using a template literal in `formatCar`. The result replaces the initial "loading..." text in an HTML `<pre>` element.

Jan 5, 2021
Loading thumbnail…

Let's make a face with D3!.js

This example builds a face out of many small circles using D3.js version 3. The SVG canvas contains a blank 960 by 500 pixel space, and the code uses d3.forceSimulation to position the nodes into a facial shape. Each circle represents a data point, and the simulation applies physical forces to arrange them into the recognizable form. The styles.css file sets the body margin to zero and hides overflow, ensuring the visualization fills the viewport. The rendering approach is purely SVG-based, with no external data source.

Jan 3, 2021
Loading thumbnail…

Shapes with SVG and CSS

This example demonstrates basic SVG shapes—circles, rectangles, lines, and paths—styled with CSS. The structure uses a static SVG document with nested groups to apply transforms like scaling and translation. Fill colors, stroke widths, and line joins come from CSS classes, while inline attributes set initial properties. The code imports no external libraries, relying purely on SVG markup and CSS. Lines and paths are grouped with named classes to control their stroke appearance, showing how CSS interacts with SVG elements without JavaScript or D3.

Jan 3, 2021
Loading thumbnail…

HTML Cars Report

This example demonstrates a basic HTML cars report as a static webpage. It displays a short list of two vehicles with their model names and prices, rendering one item in red via the `.highlighted` CSS class. The page uses vanilla HTML and an external stylesheet, with no JavaScript or D3 library loaded, contrary to the README’s mention of d3 imports. The body applies a large monospace font for a simple, readable presentation.

Jan 2, 2021
Loading thumbnail…

Untitled

This interactive visualization displays a network of nodes connected by curved links on a dark background. Using D3’s force simulation, nodes repel each other while links maintain distances, and a zoom-and-pan canvas supports exploration. The example renders paths via `d3.forceSimulation` for physics, `d3.zoom` for viewport control, and Canvas 2D drawing for real-time rendering. Node positions update each tick, with link strokes drawn as quadratic Bézier curves, and the data appears to be synthetic, generated in code. The interface runs entirely in the browser with no external data files.

Jan 2, 2021
Loading thumbnail…

Fork of Hello VizHub

This example displays the text “Hello VizHub!” in the browser, demonstrating a minimal setup for a D3.js visualization. It uses an ES6 module named `myMessage.js` to export the string, which is then imported and rendered by the main script in `bundle.js`. The page structure is defined in `index.html`, which loads D3 v5 from a CDN and applies styles from `styles.css`. The visualization shows how to combine modular JavaScript, HTML, and CSS with the D3 library.

Jan 2, 2021