N

nim@brejnholt.dk

@nimrod-grandpierre·25 public vizzes

Loading thumbnail…

Scatter Plot Including Species

This interactive scatter plot visualizes the classic Iris dataset, letting users explore relationships between sepal and petal measurements by switching axes via dropdown menus. Built with D3 v7, the visualization supports both numerical and categorical axes, with circles transitioning smoothly between positions using `d3.transition`. The scatter plot component uses `scaleLinear` and `scalePoint` for scaling, while SVG rendering and axis generation via `axisLeft` and `axisBottom` update dynamically as selections change.

Loading thumbnail…

Animated Scatter Plot with Menus

This example uses the D3.js library to render an animated scatter plot of the Iris flower dataset, where each point represents a sample and its position is determined by selected flower measurements. The visualization includes two dropdown menus for choosing which measurement (petal or sepal width/length) to plot on the X and Y axes. When a menu selection changes, the scatter plot smoothly transitions circles to their new positions over one second using D3 transitions, with a unique staggered delay between points. The plot axes also update dynamically to reflect the new data ranges.

Loading thumbnail…

Animated Reusable D3 Scatter Plot

This example animates a reusable D3 scatter plot that cycles through different iris flower measurements every 3 seconds. It uses D3’s `scaleLinear`, `axisLeft`, `axisBottom`, and the `transition` API to smoothly move circles and axes between states. The code fetches CSV data from a GitHub gist and renders SVG circles with staggered enter/update transitions, changing the x-axis mapping among petal width, sepal width, petal length, and sepal length.

Loading thumbnail…

"Buggy" Transitions on Animated Reusable D3 Scatter Plot

This example presents an animated scatter plot of the classic Iris dataset, where points smoothly transition between different variable pairings on the x-axis every two seconds. Built with D3 v7 using reusable chart components, a `setInterval` swaps the `xValue` across petal width, sepal width, petal length, and sepal length. The visualization employs `scaleLinear`, `axisLeft`, and `axisBottom` for axes, while `selection.join()` combined with `.transition()` and a 1000ms duration animates the circles' positions. The SVG rendering updates axes and marks in-place, creating evolving comparisons of flower measurements.

Loading thumbnail…

Reusable D3 Scatter Plot

This reusable D3 scatter plot animates through different iris flower measurements, cycling the x-axis column every two seconds. Built with a chainable `scatterPlot` function using `d3.scaleLinear`, `d3.axisLeft`, and `d3.axisBottom`, it renders SVG circles and axes from a CSV dataset fetched via `d3.csv`. The code demonstrates dynamic updates by re-invoking the plot with new `xValue` accessors, showing how a component can be reconfigured and reused across data dimensions.

Loading thumbnail…

Reusable D3 Scatter Plot with Symbols

This example shows a reusable scatter plot of the Iris dataset, where each flower is represented by a distinct symbol indicating its species. The plot maps petal width to the x-axis and sepal length to the y-axis, with axes added via d3.axisLeft and d3.axisBottom. The code implements a modular scatterPlot component using d3.scaleLinear for positioning, d3.scaleOrdinal with d3.symbols for shape encoding, and a chainable API for configuration. Data is loaded as CSV from a remote URL, and the entire visualization is rendered as SVG.

Loading thumbnail…

D3 Scatter Plot (Vanilla JavaScript and HTML)

This scatter plot visualizes the relationship between petal length and sepal length in the Iris dataset, with each flower represented as a circle. The SVG rendering uses d3.scaleLinear to map data values to screen coordinates and d3.axisLeft/axisBottom to draw the axes. Data loads asynchronously via d3.csv from a GitHub gist, and the code parses numeric fields before binding the marks. The example demonstrates the core pattern of joining data to SVG circles with the selection.join() method.

Loading thumbnail…

JS in HTML

This example shows how to embed JavaScript directly in an HTML page alongside D3.js. It displays a large "Hello HTML!" message styled with CSS, while the bundled script.js and index.js modules log output to the console. The code imports named exports from something.js and other.js using ES module syntax, and loads D3 v7 from a CDN via a script tag. No data visualization is present; it demonstrates basic file structure and module wiring for a D3 starter project.

Loading thumbnail…

D3 Selection Exploration (Final)

This example demonstrates animated data binding with D3 selections, showing fifteen circles that continuously move, resize, and shift color based on a time-driven sinusoidal pattern. The visualization updates at 60 frames per second via `setInterval`, with each frame regenerating fresh data through the `makeData` function. D3’s `selectAll().data().join()` pattern in `vizData.js` binds the new data to existing SVG circle elements, updating their `r`, `cx`, `cy`, and `fill` attributes. The code uses D3 v7 modules `select` and `range`, rendering entirely as SVG animation driven by the time variable `t`.

Loading thumbnail…

Creating Own Pseudo Visualization

This pseudo bar chart uses a central vertical line as a dividing axis, with five rectangles of varying widths and positions representing approximate data categories. The author, nimrod-grandpierre, manually constructs the visualization using raw SVG primitives (`<line>`, `<rect>`) within an HTML document, specifying hardcoded coordinates and fill colors (black and blue) to simulate a chart without any data-binding or layout algorithms. The SVG canvas is set to 960 by 500 pixels with a hidden overflow, and the rectangles are placed at fixed y-positions to imply categorical rows. This example demonstrates a hand-coded, static approximation rather than a data-driven solution.

Loading thumbnail…

D3 Selection Exploration (Exit Selection Effect)

This example demonstrates D3’s exit selection effect by animating a fluctuating number of circles that move along sine-wave paths. Using `d3.select`, `d3.range`, and a `setInterval` loop, it updates the data array each frame, then merges newly entered circles with existing ones via `.enter()` and `.merge()`, while `.exit().remove()` instantly deletes circles that no longer have corresponding data. The visualization uses an SVG rendering with dynamic `cx` and `cy` attributes, showing how D3 manages DOM elements for changing data sizes without transitions.

Loading thumbnail…

D3 Selection Exploration (Exit Selection Effect)

This example demonstrates D3’s exit selection effect by animating a fluctuating number of circles that move along sine-wave paths. Using `d3.select`, `d3.range`, and a `setInterval` loop, it updates the data array each frame, then merges newly entered circles with existing ones via `.enter()` and `.merge()`, while `.exit().remove()` instantly deletes circles that no longer have corresponding data. The visualization uses an SVG rendering with dynamic `cx` and `cy` attributes, showing how D3 manages DOM elements for changing data sizes without transitions.

Loading thumbnail…

D3 Selection Exploration (Enter - Update Selections Clearly Separated)

This example demonstrates the D3 enter-update pattern by animating a set of fifteen circles along a sine wave. Every five seconds, the data array is regenerated, and the code clearly separates the enter selection—which appends new circles with `circles.enter().append('circle')`—from the update selection that repositions existing elements via `circles.attr('cx', ...)` and `circles.attr('cy', ...)`. Using D3 v7 with SVG, the visualization shows how identical data keys map to existing nodes, avoiding duplication. The animation loops indefinitely using `setInterval`, and the rendering adjusts to the full browser window size.

Loading thumbnail…

JavaScript Arrays

This example demonstrates fundamental JavaScript array operations, including mapping, reducing, and sorting, using a custom `range` function and a collection of key-value objects. The code logs a sorted version of the entries array to the console, ordering objects by their `key` property in ascending alphabetical order. It also includes commented-out examples of `map`, `reduce`, and object construction, showcasing how to transform data and aggregate values. The example relies on native JavaScript array methods and imports `ascending` from the D3 library (v7.8.5), though the primary operations use built-in functionality rather than D3-specific utilities.

Loading thumbnail…

Full Sol LeWitt Reproduction with D3

This reproduction of a Sol LeWitt wall drawing uses D3.js version 7.8.5 to render layered horizontal and vertical stripes across the full browser window. The SVG output applies two distinct masks to each set of stripes, with each mask containing a row of geometric symbols generated via `d3.symbols` and `d3.symbol`. The inverted mask (white background with black symbols) and non-inverted mask (black background with white symbols) create the contrasting visual interplay characteristic of LeWitt's systematic instructions.

Loading thumbnail…

Sol LeWitt Reproduction with D3 ()

This example reproduces a Sol LeWitt-inspired piece using D3.js. Vertical and horizontal black bars are generated as SVG rectangles across the full canvas, with a circular mask and a larger irregular star-like symbol mask carving out white negative space in the center. The code uses `d3.select`, `d3.range`, `d3.symbols`, and `d3.symbol` to define the bar spacing and the vector path for the second mask. Both masks are applied via SVG `<mask>` elements to reveal the intended graphic contrast.

Loading thumbnail…

Fork of Full Sol LeWitt Reproduction with D3

A grid of horizontal and vertical black lines forms a full Sol LeWitt–style drawing, masked by overlapping diamond shapes to reveal alternating line orientations. Using D3 v7, the code creates 100 horizontal and 100 vertical rectangles on an SVG canvas, each masked via `d3.mask` with a large `symbol` path. The `renderMask` function appends SVG `<mask>` elements, using `select.append` and `attr` to set fill colors and transforms, producing the final geometric pattern.

Loading thumbnail…

Sol LeWitt Reproduction with D3 (with SVG Groups)

This is a D3.js reproduction of a Sol LeWitt art piece, rendered in SVG. The visualization shows a grid of horizontal and vertical striped rectangles overlaid on the full viewport. Two SVG masks create a central circular cutout: one mask reveals a circle in the upper layer, while the other uses inverted colors to hide the circle in the lower layer, producing a contrasting visual effect. The code uses d3.select, d3.range, and attribute chaining to generate 100 rectangles in each direction, with dimensions tied to the window size.

Loading thumbnail…

Sol LeWitt Reproduction with D3

This example reproduces a Sol LeWitt wall drawing using SVG masks and layered rectangles in D3 v7. It shows two sets of alternating horizontal and vertical stripes, each confined to a circular region in the center of the screen. The code uses `d3.select`, `d3.range`, and data joins to generate 100 rectangles per direction, while SVG `<mask>` elements with black-and-white circles define the visible circular areas. The rendering is fully SVG-based and responds to the full window size.

Loading thumbnail…

Fork of Sol LeWitt Reproduction with D3

This example reproduces a Sol LeWitt-style drawing using SVG rect elements generated with d3.selectAll, d3.range, and .join. Horizontal and vertical rectangles are rendered across the full viewport, with two overlapping SVG masks—one showing a white circle on black and the other inverted—creating a circular focal pattern. The code uses D3 v7 selection and data-binding APIs to create 100 rects in each orientation, with the masks revealing and hiding portions of the grid to mimic the geometric interplay of LeWitt’s wall drawings.

Loading thumbnail…

Fork of Sol LeWitt Reproduction Vertical

This example reproduces a Sol LeWitt–style geometric drawing using raw SVG and JavaScript. It displays a grid of alternating horizontal and vertical stripes that are revealed through two circular mask regions at the center of the canvas. The code creates an SVG element, defines two mask layers—one with a white circle on black and another with a black circle on white—and appends 100 horizontal and 100 vertical rectangles. Each rectangle is clipped by one of the masks, producing the contrasting stripe pattern without any external libraries.

Loading thumbnail…

Sol LeWitt Reproduction

This reproduction of a Sol LeWitt drawing generates 100 vertical black rectangles across the full height of the browser window. Each rectangle is positioned at increasing x-coordinates, creating a rhythmic, grid-like pattern reminiscent of LeWitt’s minimal wall drawings. The piece uses the native Document Object Model (DOM) API, specifically `document.createElementNS` and `setAttribute`, to construct SVG elements directly in JavaScript, with no external libraries. The rendering approach sets the SVG width and height to match the window dimensions, resulting in a responsive, full-screen artwork.

Loading thumbnail…

Sol LeWitt Reproduction

This reproduction of a Sol LeWitt art piece is generated entirely in SVG, rendering geometric lines and shapes in the artist’s signature style. The visualization is built using raw JavaScript within a single HTML file, with the SVG canvas sized at 960 by 500 pixels. The script defines a simple arrow function for creating person objects, logging one example to the console, but the visual artwork itself relies solely on static SVG markup. No external libraries or data sources are used, and the rendering approach is purely declarative.

Loading thumbnail…

SVG Animation using CSS transitions

This example shows a single SVG circle that animates its fill color and stroke width when hovered. The transition is defined in CSS using the `transition: all 3000ms` rule, which smoothly interpolates the circle’s `fill` and `stroke-width` properties between its normal state and its `:hover` state. The circle is rendered in a plain HTML page with inline SVG, using no JavaScript libraries—only CSS and the SVG element itself. The hover effect changes the circle from blue to red and expands its stroke from 20px to 100px.

Loading thumbnail…

SVG Fundamentals

This example demonstrates fundamental SVG shapes and styling in a static scene. It shows a blue circle, two diagonal lines, and a black polyline path, all defined within an inline SVG element. The code uses raw SVG markup with elements like `<circle>`, `<line>`, and `<path>`, applying attributes such as `stroke`, `stroke-width`, and `fill`. A separate file, hover.html, explores CSS transitions on SVG circles, changing fill color and stroke width over three seconds when hovered.