Skip to main content
100%

Gist 788c07fefb1d6fb9dfe6d546010188e1

✓ Published0🌍 Public
Aandybak
Last edited Jul 13, 2024
Created on Jul 13, 2024

The visualization displays a pie chart of file type counts across a directory tree, highlighting dominant extensions while omitting labels and percentages for slices under 5%. It also computes and prints statistics for GLTF generators, JSON format types, and directory extension combinations. The chart is rendered with Matplotlib’s `plt.pie`, using `autopct_func` to conditionally show percentages and larger font sizes for readability. Data is collected by scanning subdirectories with `os.walk` and JSON parsing via `json.load`.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 97014fa0c26abd2904c7ba9d22ab9e57

This visualization maps the structure of Google Poly’s 3D asset files by parsing embedded JSON from saved HTML pages. It converts transformation matrices into quaternions, translations, and scales, then categorizes each file’s role (e.g., original glTF, USDZ, OBJ) using role IDs. The code processes thousands of assets, extracting metadata to reveal how different file formats and roles are distributed across the collection. It relies on Python’s `json`, `re`, `math`, and `os` modules for data extraction and matrix decomposition, with the final output intended for further analysis or charting.

Aandybak
64% 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
63% match
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
63% match
Loading thumbnail…

Gist 5a230baa1dc731fde7251b37d84d1866

This example visualizes the extension packages and sync settings from a Visual Studio Code configuration, using a force-directed layout to position each extension as a node within a cluster. The graph is rendered with Three.js and uses d3.forceSimulation to simulate physics for realistic node interactions and clustering. The data is sourced from a JSON array of extensions, including metadata such as publisher, name, and version, and is paired with a settings file that includes a custom sync Gist ID. The visualization highlights the relationships and dependencies among these development tools.

LLeonardonline
62% 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
61% match
Loading thumbnail…

Pie Chart

This pie chart shows the distribution of person types from a CSV file, using a color-coded slice for each category with labels and a corresponding legend. The chart is built with D3.js v7, using `d3.pie` to compute the arc segments, `d3.arc` for the path geometry, and `d3.scaleOrdinal` with `d3.schemeCategory10` for the color palette. Data is loaded via `d3.csv` from a GitHub-hosted source, and mouseover events log the person type to the console.

MMonish Galla
61% match
Loading thumbnail…

Piecharticons

This visualization shows the distribution of car types from a CSV dataset as a pie chart with an adjacent legend. It uses d3.pie and d3.arc to generate the slices, each filled with a color from d3.schemeSet2 via a d3.scaleOrdinal. Type labels are placed using labelArc centroids, and the legend is built with D3 selections on HTML divs, listing each car type with its corresponding count. The chart is rendered as SVG, with data aggregated using d3.rollup.

GGorantla Vishnusai
61% match
Loading thumbnail…

Pie Chart

A pie chart built with D3 v7 displays the distribution of car types from a CSV file hosted on a GitHub Gist. The visualization aggregates raw records into categorical counts by type—Sedan, SUV, Truck, and Coupe—and shows each segment's percentage share using `d3.scaleOrdinal` with the `d3.schemeSet2` palette. D3's `arc` generator positions slices, while leader lines and external labels annotate each wedge. An interactive legend, populated via the `d3.select` API, highlights corresponding slices on hover, and a tooltip provides additional detail. The chart uses SVG rendering.

RRamdas Dheeraj
61% match