Skip to main content
SimilarExport ZIP
100%

Sol Le Witt practice

✓ Published0🌍 Public
Ppanthabuddhi@gmail.com
Last edited Feb 19, 2024
Created on Feb 19, 2024

This visualization recreates Sol LeWitt’s geometric wall drawings as an interactive abstract composition. It shows a dense grid of lines and arcs that respond to mouse movement, with overlapping strokes and subtle color shifts. The piece uses d3.forceSimulation to animate the positions of line endpoints, while a canvas rendering loop draws the paths each frame. Input data comes from a predefined set of coordinates and angles, not from an external dataset. The code relies on D3’s scale functions and the Canvas API, with no additional libraries beyond D3.

AI-generated description
MIT Licensed

Similar vizzes

Loading thumbnail…

Untitled

This example reproduces a Sol LeWitt wall drawing as an interactive visualization, showing how a set of algorithmic rules generates a complex geometric composition. A force-directed layout using `d3.forceSimulation` positions a grid of nodes, while SVG paths are drawn with `d3.line` and `d3.curveBasis` to create the characteristic arcs and straight segments. The code reads a local data file defining the drawing’s parameters and renders them in a browser window, with user interaction via mouse events to pause or restart the simulation. The result is a faithful, animated tribute to LeWitt’s instructions-based art.

MMonWas
86% match
Loading thumbnail…

Sol le Witt practice

This example reproduces a Sol LeWitt wall drawing using SVG. It shows a static geometric composition of lines and shapes, exploring the artist's algorithmic approach to visual form. The sketch uses an SVG canvas set to 960 by 500 pixels, with basic HTML and JavaScript structure. The current code only initializes the drawing area and logs a message to the console, without yet implementing the drawing logic or any data-processing libraries.

Ppanthabuddhi@gmail.com
84% match
Loading thumbnail…

sol lewit reproduction assignment

This visualization reproduces the geometric precision of Sol LeWitt’s wall drawings using D3.js, encoding alternating vertical and horizontal line grids. It renders a series of thin rectangles that are selectively masked by SVG masks containing paths of abstract symbols, creating overlapping patterns of positive and negative space. The code leverages D3’s `select`, `range`, `symbols`, and `symbol` APIs to generate the grids and symbol paths, with masks (`url(#mask0)`, etc.) toggling visibility. The result is a dynamic, screen-sized composition that mirrors LeWitt’s systematic, rule-based aesthetics through algorithmic drawing.

KKerim
83% match
Loading thumbnail…

Sol LeWitt reproduction

This example reproduces a Sol LeWitt wall drawing as a dynamic, algorithmic visualization. It shows a grid of colored squares whose hues gradually shift and blend over time, creating a living, patterned composition. The work uses D3.js to construct and manipulate SVG elements, with colors derived from an interpolated palette. The rendering relies on JavaScript timers or animation frames to cycle through color values, updating the fill of each rectangle to mimic LeWitt’s serial, rule-based aesthetic. The code is minimal, containing no external data or complex geometry, focusing purely on the interplay of color and grid structure.

PPolydexter
83% match
Loading thumbnail…

Sol LeWitt Episode 4 Practice

This visualization reproduces Sol LeWitt’s geometric drawing practice by overlaying two sets of thin, evenly spaced rectangles—horizontal and vertical—to form a grid across the full viewport. Using D3.js, the code creates 100 rectangles in each direction, with masks applied to selectively reveal or hide portions of the grid. Two custom masks, defined via SVG, use D3 symbols (circle, cross, diamond, square, star, triangle, and wye) to punch out or block shapes at the center, creating an inverted interplay between the two layers. The result is a clean, algorithmic composition that echoes LeWitt’s wall-drawing aesthetics through simple SVG primitives and data-driven iteration.

SSam Hege
83% match
Loading thumbnail…

Sol LeWitt Reproduction with D3

This piece recreates a Sol LeWitt wall drawing using D3.js to generate layered, mask-based geometric forms. It displays a grid of horizontal and vertical lines that intersect within a central circular region, creating a dynamic visual pattern. The code uses the D3 selection API and raw SVG elements, employing two circular masks to selectively reveal the line structures. The rendering is dynamically sized to fit the browser window, producing an interactive, generative art experience.

Ssean@wall.ninja
83% match
Loading thumbnail…

Sol LeWitt With D3

This example recreates a Sol LeWitt wall drawing using D3.js to render layered geometric abstractions in SVG. The visualization combines horizontal and vertical striped rectangles with concentric arc paths, all filtered through SVG masks that selectively reveal or hide portions of each shape across the viewport. The code uses D3 selections with `range()` to generate repeated elements, `.join()` for data binding, and `mask` attributes to composite intersecting forms. The result is a dynamic, generative composition that responds to the browser window dimensions while echoing LeWitt’s systematic, rule-based artistic style.

Jjony6290
82% match
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 intersect to form a subtle pattern across the full browser viewport. The piece relies on two SVG masks—one circular and one rectangular—to selectively reveal or hide portions of the line arrays. Specifically, a path generated via `symbol(symbols[1],100000)` creates a large circular mask over the vertical lines, while a black circle mask obscures the horizontal lines in a contrasting region. The code uses D3’s `select`, `range`, and `join` APIs to efficiently append hundreds of SVG rect elements, with all rendering performed client-side in SVG format.

Gguts
82% match