Skip to main content
100%

Gist 777424

✓ Published0🌍 Public
XXXX
Last edited Jan 13, 2011
Created on Jan 13, 2011

This visualization displays a collection of image files from a local corpus, listing filenames and their paths as a Processing script scans a directory. It shows the file discovery process, including successful finds and error messages for files that fail to load. The code uses CImg library methods like `load()` and `sum()` to handle image processing, catching exceptions for unrecognized formats or empty instances. The output presents a text-based log of the scanning operation, revealing the variety of image types encountered.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 0bb5514393bdd878235e51ed2fdd3724

This example visualizes the relationships between file names and their associated directory paths using a force-directed graph layout. The code employs `d3.forceSimulation` to position nodes and `d3.forceLink` to draw connecting edges, with each node rendered as a colored circle. The graph is built from a parsed file tree structure, likely derived from object keys or an array of paths, and uses `d3.select` for DOM manipulation. Labels are attached to nodes via SVG text elements, while the simulation updates positions on each tick. The rendering relies on an SVG container, with node colors distinguishing file types from directory paths.

RRainboylvx
61% match
Loading thumbnail…

Gist 2bba23d8eda3ce767e87a6a491773372

The visualization is a scatterplot-style mosaic representing a 1000x1000 grid, plotting the positions and sizes of 234 rectangular claims from an Advent of Code puzzle. Overlapping rectangles accumulate, creating a dense heatmap-like field of colored blocks on a dark background. Built with Processing, the sketch loads the claim data from `aoc3_1.txt` and renders each rectangle using `rect()`, varying color intensity based on overlap count. The code uses `loadStrings()` to parse the input file and calls `noLoop()` to draw the static result once.

BBBischof
61% match
Loading thumbnail…

Gist 585199

This visualization loads an external CSV file and parses its rows into JavaScript objects, mapping each column name from an array to the corresponding values in each line. It handles quoted fields that contain commas by merging split segments until the quote count is even, and it logs warnings for malformed lines that do not match the expected number of columns. The example demonstrates a reusable CSV-asynchronous-loading helper, but does not show any charting, layout, or rendering code beyond the data preparation stage.

RRandomEtc
60% match
Loading thumbnail…

Gist db32a113f546aa03b43c0e1f84f80d28

The visualization shows a force-directed network graph of GitHub gist data, with nodes representing individual gists and links showing relationships between them. It uses d3.forceSimulation to compute the layout, with node size encoding gist size and color indicating file type or language. The rendering relies on SVG elements updated per tick via the simulation’s tick event. The code loads a static JSON file containing preprocessed gist metadata, and does not use canvas or WebGL. The visualization highlights clustering patterns among related gists, revealing emergent communities in the dataset.

335degrees
60% match
Loading thumbnail…

Gist bf027117c9b0bdfb633414ab5bd84877

This example visualizes a network of file and folder connections from a Gist repository, using a force-directed graph layout to reveal clustering and link patterns. The code employs D3.js’s `d3.forceSimulation` with `forceLink` and `forceManyBody` to position nodes, while SVG paths and circles render the edges and vertices. A drop-down menu lets users filter the displayed links by type, and the visualization includes a legend and hover tooltips. The underlying data is hardcoded as a JavaScript array of node and link objects, reflecting the structure of a GitHub Gist.

MMistyBlunch
59% match
Loading thumbnail…

Gist 8e4a7859bf351698daff

This example displays a collection of Git command-line snippets organized by workflow categories, with each command as a labeled node. The visualization uses D3.js to render these commands as interactive text elements, applying a force-directed layout to spatially group related commands like repository creation, branching, and syncing. The code references `d3.forceSimulation` for positioning nodes and includes the raw command strings from a public Gist, with no external data fetching. Each node displays its command syntax and a brief comment, while the layout dynamically adjusts to avoid overlap based on the text content.

LLayne Smith
59% match
Loading thumbnail…

Gist 968bea4c8a1c394a4de656559493d66a

This visualization presents a tree map of broken HTTP links from a report, with each file path represented as a branch and the HTTP status codes (404, 401) displayed as color-coded nodes. The layout uses a hierarchical structure to show the relationships between the download URLs and their associated error types, allowing viewers to quickly identify which resources are failing and how errors cluster across different datasets.

TThomasG77
59% match
Loading thumbnail…

Gist 5f3654a871cd25cd4baf9fd51347d607

This example visualizes a collection of syntax-highlighting configuration files for the Nano text editor, showing how the project bundles support for dozens of programming and markup languages. The visualization uses a network graph built with D3.js’s `d3.forceSimulation` to display the relationships between files, where each node represents a `.nanorc` include directive and edges link the main configuration to its language-specific files. The rendering relies on `d3.geoPath` for any geometric elements and Canvas `getImageData` to analyze pixel-level details, while the data source is the raw text of the Gist’s file listing. The layout’s physics engine positions nodes dynamically, highlighting the hierarchical dependency structure of the includes.

115Dkatz
58% match