B

bindhureddy98

@bindhureddy98·59 public vizzes

Loading thumbnail…

Fork of Fork of Fork of Tree 7

A clickable, animated tree diagram shows hierarchical data loaded from a local JSON file. Clicking a node toggles its children, collapsing or expanding subtrees with smooth transitions. The visualization uses D3 v3’s `d3.layout.tree` to calculate node positions and `d3.svg.diagonal` to draw curved links, while SVG circles and text labels update via `transition()` over 1100 milliseconds. Node fill colors distinguish collapsed branches from open ones.

Loading thumbnail…

Fork of Fork of Force Network

A force-directed network chart maps actors, directors, and films into colored nodes, with links representing acting or directing relationships. The layout uses `d3.forceSimulation` with forces for links, charge, collision, and centering. Circles are colored by a `scaleOrdinal` group mapping, and SVG markers define arrowheads for links. Data loads from `data.json`, and nodes support drag interaction via `d3.drag`. Labels and relationship text are appended but incomplete, while the tick handler updates line and circle positions.

Loading thumbnail…

Fork of Force Network

A force-directed network diagram maps actors and directors to their films, with nodes colored by group and sized by connection value. Draggable circles represent people and movies, while gray lines show relationships such as "Acted in" or "Directed." The visualization uses D3 v6's `d3.forceSimulation` with link, charge, collision, and center forces, rendering nodes as SVG circles and links as lines with markers. Data comes from a local JSON file, loaded via `d3.json`.

Loading thumbnail…

Fork of array to tree

This example converts a random array of numbers into a hierarchical tree structure. Using D3 v6, it applies `d3.stratify` to build the hierarchy from parent-child relationships, then `d3.tree` to compute node positions. The animation updates node text values with staggered `transition` delays based on tree depth. Red-stroked SVG circles represent nodes, and black paths connect parent and child positions. The visualization demonstrates dynamic re-rendering of tree data with smooth text transitions.

Loading thumbnail…

Fork of Fork of Organization Graph Diagram

This visualization presents an organization graph of arts-related communities, using a force-directed layout to reveal the hierarchical structure between two main entities and their subsidiary groups. The code constructs a network from predefined nodes and links, where main, child, and leaf nodes are given distinct sizes to indicate their level in the hierarchy. Using D3 v6, the example employs `d3.forceSimulation` with `forceManyBody`, `forceLink`, and `forceCenter` to position the nodes dynamically. The SVG output displays gray circles connected by lightgray lines, with text labels for each node, rendered through a tick event that updates the coordinates.

Loading thumbnail…

Fork of Force Directed Graph Starter

This fork of the D3 force-directed graph starter visualizes a small network of three nodes (Alice, Bob, Carol) connected by two directed links. The example uses D3’s `forceSimulation` with `forceManyBody`, `forceLink`, and `forceCenter` forces to position the nodes dynamically. As the simulation ticks, the SVG circles and lines update their coordinates via the `simulation.on('tick')` callback. The rendering is done with SVG elements, drawing black lines for links and circles for nodes, all contained in a 960×500 pixel canvas.

Loading thumbnail…

Fork of Force Network

This force-directed network visualization uses d3.forceSimulation to map relationships between actors, directors, and films from a JSON data source. Nodes are rendered as colored circles in SVG, with link lines showing connections and arrowheads indicating direction. The code implements drag interactions and adjusts node positions through the simulation's tick handler, while link labels display truncated relationship types.

Loading thumbnail…

Fork of Fork of Fork of Tree 7

A clickable, animated tree diagram shows hierarchical data loaded from a local JSON file. Clicking a node toggles its children, collapsing or expanding subtrees with smooth transitions. The visualization uses D3 v3’s `d3.layout.tree` to calculate node positions and `d3.svg.diagonal` to draw curved links, while SVG circles and text labels update via `transition()` over 1100 milliseconds. Node fill colors distinguish collapsed branches from open ones.

Loading thumbnail…

Fork of Fork of Tree 7

This example presents a collapsible node-link tree diagram that visualizes a small hierarchical dataset from a JSON file. The visualization loads the JSON data and displays it as an interactive tree, where users can click on nodes with children to expand or collapse branches. The tree layout is computed using `d3.layout.tree` and rendered as an SVG graphic, with nodes drawn as circles and connections as diagonal path links. The visualization uses the `qn_tree.json` data source, and all transitions between expanded and collapsed states are animated with D3's `.transition()` method.

Loading thumbnail…

Fork of Tree 7

This interactive tree diagram visualizes a hierarchical dataset loaded from a JSON file, using a collapsible node layout. The visualization employs D3.js version 3.5.17, specifically `d3.layout.tree` for tree layout and `d3.svg.diagonal` for curved link paths. Nodes are rendered as circles with text labels, and clicking a node toggles its children, triggering a smooth 1100ms transition animation that repositions nodes and links. The SVG-based rendering supports interactive exploration of the nested family-tree-like structure.

Loading thumbnail…

Fork of Interactive Tree Updated

This interactive tree diagram visualizes a hierarchical dataset of question-facing outcomes, where each node is colored according to its state and labeled with its name. The visualization supports user interaction by allowing nodes to be collapsed or expanded on click. Built with d3.v5, it uses `treeLayout` and `linkHorizontal` to position nodes and draw edges, while SVG groups and rectangles represent each node. The animation of transitions is handled through d3's `.transition()` API, which smoothly updates node positions and path connections during structural changes.

Loading thumbnail…

Fork of Tree

This example presents a branching tree visualization built with D3.js v6. The code uses `d3.stratify()` to structure a dataset of named parent-child relationships into a hierarchy, then `d3.tree().size()` to compute the node positions. The animation, rendered as SVG, reveals the tree structure by initially drawing each connection as a zero-length path from the source node, then transitioning it over one second to its full line. Node labels appear sequentially using `transition().duration(d => 100 + d.depth*1000)`, creating a cascading effect where labels near the root appear before those at deeper levels. The circular nodes use a red stroke with white fill.

Loading thumbnail…

Fork of india map

This interactive visualization displays India’s administrative divisions, using distinct colors for districts and dark green highlighting on hover. It also marks state boundaries with a black stroke. The map is rendered as SVG using `d3.geoPath` with a Mercator projection, and supports zoom and pan via `d3.zoom`. District and state boundaries come from TopoJSON files, with district names and states shown as tooltips. The code also loads a CSV of Indian cities, though city markers are not rendered.

Loading thumbnail…

india map

This interactive visualization displays a choropleth map of India, with district-level polygons colored by state and state boundaries outlined in black. Users can pan and zoom the map using d3.zoom. The map is rendered with SVG paths generated by d3.geoPath and a d3.geoMercator projection. District and state boundaries come from TopoJSON files, with district tooltips showing district and state names on hover. The map uses d3.scaleOrdinal with d3.schemeCategory10 for district coloring.

Loading thumbnail…

Fork of Fork of Fork of World Map

This example displays an interactive world map using D3.js and the d3-geo-projection library. Users can drag to rotate the orthographic projection and click on individual countries to toggle between orthographic and Mercator projections; clicking the United States switches to a US-focused AlbersUSA projection. The visualization renders country boundaries as SVG paths via d3.geoPath, with a graticule overlay, and uses d3.drag and d3.zoom for interaction. It loads geographic data from TopoJSON (world-atlas) and country names from a TSV file.

Loading thumbnail…

Fork of Fork of World Map

This interactive map renders world countries from the `world-atlas` TopoJSON dataset, using a choice of either the orthographic or Mercator projection from `d3-geo-projection.v3`. Users can click a country to toggle between the two projections, and the map supports drag-to-rotate via `d3.drag()` and zooming through `d3.zoom()`, which applies an SVG transform. Country names are joined from a TSV file, and all paths are generated with `d3.geoPath`, with hover highlighting provided by CSS.

Loading thumbnail…

Fork of map with legend

This example renders a choropleth map of Indian states, coloring each state by its `AREA_` attribute using a sequential rainbow color scale. The map is drawn as SVG paths via `d3.geoPath` with a `d3.geoMercator` projection fit to the window size. State boundaries come from a TopoJSON file loaded with `d3.json` and converted to GeoJSON using `topojson.feature`. React manages the component lifecycle, while `d3.scaleSequential` maps data extents to colors; a separate SVG element is prepared for a legend, though the legend itself is not implemented in the visible code.

Loading thumbnail…

Fork of Fork of Fork of Map of India with D3 - chloropleth map

This choropleth map renders the states of India as SVG paths, with each state colored by a categorical scale and labeled with its name at the path centroid. The visualization uses d3.json to load TopoJSON state boundaries, then converts them with topojson.feature and projects them using d3.geoMercator. d3.geoPath generates the path data, while d3.scaleOrdinal and d3.schemeCategory10 assign fill colors. State names are placed via d3.geoPath.centroid, and the first feature is removed from the dataset before rendering.

Loading thumbnail…

Fork of Fork of Map of India with D3 - chloropleth map

This choropleth map displays the states of India, each filled with a distinct color from a categorical scale and labeled with its name. The visualization uses D3 v5 and TopoJSON to load and render state boundaries from a GitHub-hosted TopoJSON file. SVG paths are generated with `d3.geoPath` and a Mercator projection, with state labels positioned using `pathGenerator.centroid`. The code assigns fill colors via `scaleOrdinal` and `schemeCategory10`, and applies static styling through CSS classes.

Loading thumbnail…

Fork of Family tree

This interactive D3.js visualization presents a hierarchical family tree, rendering the relationships from a grandfather down through multiple generations in an animated, expandable layout. Built with D3 v3 and jQuery, it uses SVG elements to draw nodes and links, with color-coded nodes representing different family member types. The visualization supports zoom, drag, and click interactions to explore the tree’s structure, incorporating smooth transitions and tooltips. The code uses `d3.layout.tree` for layout calculation, `d3.behavior.zoom` for pan/zoom functionality, and custom `breadthFirstTraversal` logic to manage node spacing and collision detection.

Loading thumbnail…

Family tree

This interactive family tree visualization displays hierarchical relationships using a box-and-link diagram, with color-coded nodes representing different family member categories. Built with D3.js v3 and jQuery, the SVG-based tree supports zooming, dragging, and click interactions to explore the nested JSON data structure. The layout uses d3.layout.tree to position nodes, with animated transitions and tooltips that appear on hover, while custom utilities like breadthFirstTraversal handle collision detection and dynamic height calculation.

Loading thumbnail…

Fork of Fork of Map of India with D3 - chloropleth map

This choropleth map displays the states of India, each filled with a distinct color from a categorical scale and labeled with its name. The visualization uses D3 v5 and TopoJSON to load and render state boundaries from a GitHub-hosted TopoJSON file. SVG paths are generated with `d3.geoPath` and a Mercator projection, with state labels positioned using `pathGenerator.centroid`. The code assigns fill colors via `scaleOrdinal` and `schemeCategory10`, and applies static styling through CSS classes.

Loading thumbnail…

Fork of World Map

This interactive map visualizes world countries using the Orthographic and Mercator projections, rendered as SVG paths. Users can drag to rotate the globe and click countries to switch between projections, with the United States uniquely triggering the Mercator view. The visualization uses `d3.geoPath`, `d3.geoGraticule`, and `d3.drag` for interaction, loading country boundaries from `world-atlas` JSON and names from TSV data. Hovering highlights countries, and a zoom API adjusts the SVG group’s transform.

Loading thumbnail…

Fork of Polished World Map

This visualization displays a world map with country boundaries and graticules, rendered as an SVG using React and D3. The map is created from World Atlas TopoJSON data, with land areas filled in teal and graticule lines in light gray. The code uses `geoNaturalEarth1` for projection, `geoPath` to render geographic features, and `geoGraticule` to draw the graticule grid. Interior boundaries between countries are highlighted with a distinct stroke color, enhancing the map’s visual polish.

Loading thumbnail…

Fork of Fork of Fork of Fork of Fork of D3: GeoEarth

This example shows a world map colored by deaths from brain and central nervous system cancer for 2019, using a yellow-orange sequential color scale. It renders geographic features with `d3.geoPath` and `geoNaturalEarth1`, pulling country shapes from world-atlas TopoJSON and matching them to CSV data via country codes. A mouseover tooltip appends the country name and death count, while a legend displays the color scale’s range. The code uses React hooks to load data and D3 v7 for mapping, with the topojson library for feature extraction.

Loading thumbnail…

Fork of Fork of Fork of Fork of D3: GeoEarth

This choropleth map visualizes 2019 global deaths from brain and central nervous system cancer, coloring each country according to its death count using a yellow-to-red sequential scale. A legend shows the color mapping, while hovering over a country reveals its name and total deaths in an on-screen tooltip. The visualization combines TopoJSON country boundaries with CSV data, projecting them using d3.geoNaturalEarth1 and d3.geoPath. Built with React and styled with SVG, it loads data via d3.csv and renders interactive paths that respond to mouse events.

Loading thumbnail…

Fork of Fork of Fork of D3: GeoEarth

This choropleth map visualizes global deaths from brain and central nervous system cancer for 2019, using a yellow-orange-red sequential color scale to encode mortality counts by country. The visualization uses React for component structure and D3 v7 APIs including `d3.geoNaturalEarth1`, `d3.geoPath`, and `d3.scaleSequential` to render the map, with TopoJSON world atlas data for country boundaries. A legend displays graduated color swatches, and hovering over a country reveals its name and total death count via D3 selections on a DOM overlay.

Loading thumbnail…

Fork of Fork of Fork of D3: GeoEarth

This choropleth map visualizes global deaths from brain and central nervous system cancer for 2019, using a yellow-orange-red sequential color scale to encode mortality counts by country. The visualization uses React for component structure and D3 v7 APIs including `d3.geoNaturalEarth1`, `d3.geoPath`, and `d3.scaleSequential` to render the map, with TopoJSON world atlas data for country boundaries. A legend displays graduated color swatches, and hovering over a country reveals its name and total death count via D3 selections on a DOM overlay.

Loading thumbnail…

Fork of D3: GeoEarth

This choropleth map visualizes deaths from brain and central nervous system cancer across countries for 2019, using a yellow-to-red sequential color scale to encode mortality counts. The visualization renders world geography with `d3.geoNaturalEarth1` and `d3.geoPath`, combining TopoJSON country boundaries from the World Atlas with CSV health data joined via country codes. React manages interactive state, while D3’s `scaleSequential` with `interpolateYlOrRd` drives the color encoding. Hovering over a country displays its name and total deaths in a floating toolkit, and a legend shows the scale’s domain.

Loading thumbnail…

Fork of Fork of D3: GeoEarth

This interactive choropleth map visualizes global deaths from brain and central nervous system cancer for 2019, with countries colored on a yellow-to-red sequential scale using d3.scaleSequential and interpolateYlOrRd. The geographic projection is rendered via d3.geoPath with geoNaturalEarth1, while country boundaries come from World Atlas TopoJSON data and mortality statistics are joined from CSV files. A legend and hover tooltip, implemented with React state and D3 selections, display country names and death counts. The visualization uses React to manage the component lifecycle and d3.v7 for data loading, mapping, and SVG rendering.

Loading thumbnail…

Fork of D3: GeoEarth

This interactive choropleth map visualizes global brain and central nervous system cancer deaths for the year 2019, colored using a yellow-to-red sequential scale. Built with React and D3 v7, it uses `d3.geoPath` and `d3.geoNaturalEarth1` for map projection, while `d3.csv` loads the data appended to a TopoJSON world atlas. A legend and hover tooltip, implemented with `d3.select`, show the total death counts per country.

Loading thumbnail…

Fork of ICE 7 Area Chart

This area chart shows car sales in India from 2009 to 2019, with a black smoothed line tracing the trend and an orange filled region beneath it. The visualization uses D3 v5’s `scaleTime` and `scaleLinear` to map years and sales values, while `line` and `area` generators with `curveBasis` create the curved shapes. Axis ticks are rendered as gridlines, and the CSV data is loaded from a GitHub gist, with dates parsed via `d3.timeParse`.

Loading thumbnail…

Fork of Fork of ICE 7 Line Chart

This chart visualizes car sales in India from 2009 to 2019, using a line plot to show the trend over time. The SVG is rendered with D3 v5, using `scaleTime` and `scaleLinear` for the axes, `axisBottom` and `axisLeft` for ticks, and the `line` generator to create the path. Sales values are formatted with `d3.format`, and data is loaded from a CSV via `d3.csv`. Grid lines and a styled red line are added for clarity.

Loading thumbnail…

Fork of ICE 7 Line Chart

This line chart shows car sales in India from 2009 to 2019, with a red line tracking annual sales values against a time-based x-axis. The D3 v5 code uses `scaleTime` and `scaleLinear` to map the data, `axisBottom` and `axisLeft` for labeled axes with grid lines, and `line` to generate the path. Data is loaded from a CSV file hosted on GitHub, and the SVG rendering is styled via an external CSS file that sets the dark background, red accents, and thick stroke for the line.

Loading thumbnail…

Fork of ICE 7 Line Chart

This line chart shows car sales in India from 2009 to 2019, with a red line tracking annual sales values against a time-based x-axis. The D3 v5 code uses `scaleTime` and `scaleLinear` to map the data, `axisBottom` and `axisLeft` for labeled axes with grid lines, and `line` to generate the path. Data is loaded from a CSV file hosted on GitHub, and the SVG rendering is styled via an external CSS file that sets the dark background, red accents, and thick stroke for the line.

Loading thumbnail…

Fork of Fork of ICE 7 Pie Chart

This pie chart visualizes the top 10 car-producing countries in the world based on 2019 data. It displays the total production value for each country as a proportional slice, with a legend identifying each country by name and value. The chart uses D3.v5’s `pie`, `arc`, and `scaleOrdinal` APIs to compute and render the SVG segments. Data is loaded from a CSV file via `d3.csv`, and the chart is positioned using `svg.append` with a translate transform. Colors are assigned from a custom range, and legend values are formatted using `d3.format`.

Loading thumbnail…

Fork of ICE 7 Pie Chart

This pie chart displays the top 10 car-producing countries by their 2019 total values, using a color-coded legend with country names and abbreviated figures. The visualization loads CSV data from a GitHub gist via `d3.csv`, then calculates totals and renders an SVG pie using `d3.pie`, `d3.arc`, and `d3.scaleOrdinal` for color mapping. Legends are manually positioned with appended circles and text elements, and values are formatted using `d3.format` with a "K" suffix.

Loading thumbnail…

Fork of ICE 7 Reusable D3 Scatter Plot

This scatter plot visualizes the Iris dataset, mapping petal width against sepal length, with each species represented by a distinct SVG symbol. Built as a reusable chart module using D3 v6, it employs `scaleLinear`, `axisLeft`, `axisBottom`, and `scaleOrdinal` for positioning and symbol encoding. The axes and points update dynamically every 15 seconds as the x-axis cycles through four measurement columns. The visualization uses an SVG rendering approach with animated transitions between attribute mappings.

Loading thumbnail…

Fork of Fork of ICE 7 Area Chart

This visualization combines a line chart and an area chart to display sales trends over time, with the area fill highlighting the magnitude of change. The chart uses a time-scaled x-axis and a linear y-axis with gridlines, and the line is smoothed using a basis curve. Built with D3 v5, the code creates SVG paths via the `line` and `area` generators, and loads its data from a CSV file containing population figures.

Loading thumbnail…

Fork of ICE 7 Area Chart

This area chart visualizes car sales in India from 2009 to 2019. It uses a combination of a line and an area chart to show the sales trend over time. The visualization is built with D3 v5 and renders as an SVG, using the `d3.area` and `d3.line` generators with a basis curve to create a smooth path. Data is loaded from a CSV file, with the year parsed using `d3.timeParse` and sales values converted to numbers. The chart includes labeled axes and a colored area fill to emphasize the data.

Loading thumbnail…

Fork of Pie Chart

This example visualizes 2022 US auto sales by brand as a pie chart, showing each brand’s year-to-date sales as a slice of a donut. The chart uses a categorical color scale to distinguish brands and includes a legend with each brand’s name and sales value in thousands. Built with D3 v5, the code loads CSV data from a GitHub gist using `d3.csv`, then constructs the pie with `d3.pie` and `d3.arc`, and renders the SVG paths and legend using `d3.select` and `d3.scaleOrdinal`.

Loading thumbnail…

Fork of Line Chart with Multiple Lines

This visualization shows a week of temperature data for cities around the world, with each city represented by a colored line plotted against time and temperature axes. The chart uses d3.scaleTime, d3.scaleLinear, and d3.scaleOrdinal with d3.schemeCategory10 to map data values, while d3.line with curveBasis generates the smoothed paths. A custom colorLegend displays the city names, and the data comes from the Data Canvas - Sense Your City project, loaded from a CSV file. The SVG rendering includes axis labels, grid lines, and a title, with the line paths styled using mix-blend-mode for visual distinction.

Loading thumbnail…

Fork of Fork of Fork of Fork of Pie Chart

This example shows the top 10 countries by population as a pie chart, with a legend displaying brand names and values. It loads CSV data via `d3.csv`, processes it, and renders the chart using `d3.pie` and `d3.arc` to create the segments. Color encoding is handled with `d3.scaleOrdinal`, and the SVG output is appended to the document. The visualization highlights the proportional population distribution among the countries.

Loading thumbnail…

Fork of Fork of Fork of Pie Chart

This example visualizes 2022 US auto sales by brand using a pie chart built with D3 v5. The chart displays proportional slices for each brand, with a legend showing brand names and corresponding sales values in thousands, alongside color-coded rectangles. The code loads CSV data from a GitHub gist via `d3.csv`, processes it with `d3.pie`, and renders SVG paths using `d3.arc` with ordinal color scaling. Legends are appended as SVG groups, and sales values are formatted with `d3.format`.

Loading thumbnail…

Fork of Fork of Pie Chart

This chart shows 2022 US auto sales by brand as a pie chart with a color-coded legend displaying each brand's name and sales volume in thousands. The visualization loads data from a CSV file hosted on a GitHub gist, then uses the D3.js pie, arc, and scaleOrdinal APIs to generate the chart and legend within an SVG container. Each segment's fill color is mapped based on the brand's year-to-date sales value, and legend values are formatted using the d3.format API.

Loading thumbnail…

Fork of Pie Chart

This example shows 2022 US auto sales by brand as a pie chart, with a color-coded legend listing each brand and its total sales in thousands. The code loads CSV data from a GitHub gist using `d3.csv`, then computes the pie layout with `d3.pie` and draws the segments with `d3.arc`. Colors are assigned via `d3.scaleOrdinal`, and the chart is rendered as SVG in a 960×500 viewport, with a separate legend group built from the same data.

Loading thumbnail…

Pie Chart

This pie chart visualizes the YTD sales distribution across brands in the iris dataset, with each slice colored and accompanied by a legend showing brand names and sales values in thousands. The visualization uses D3 v5 within a React framework, loading data from a CSV file via `d3.csv`. The chart is rendered as SVG, employing `d3.pie` to compute arc angles, `d3.arc` for path generation, and `d3.scaleOrdinal` for categorical colors, with formatted values using `d3.format`.

Loading thumbnail…

Fork of Fork of Fork of ICE-6: Rendering Marks and Channels with React & D3

This visualization displays a horizontal bar chart of the ten most populous countries, using population data from 2019 loaded via `d3.csv`. The chart renders as SVG elements, with blue `rect` marks representing each country's population and custom axis ticks generated through `scaleLinear` and `scaleBand`. The code integrates React hooks (`useState`, `useEffect`) with D3 v5 utilities, using `d3.max` for scaling, while manually constructing the axes and gridlines within the JSX structure.

Loading thumbnail…

Fork of Fork of ICE-6: Rendering Marks and Channels with React & D3

This example shows a horizontal bar chart of the ten most populous countries, using population data from 2019 loaded from a CSV file. The chart is built with React and D3 v5, rendering SVG marks for bars and text labels. It uses `scaleBand` for the y-axis, `scaleLinear` for the x-axis, and `csv` to parse the data, with bars colored steelblue and axis ticks drawn manually.

Loading thumbnail…

Fork of Iris Dataset Scatter Plot

This example visualizes the Iris Dataset, plotting petal length against petal width for three iris species, each colored blue, red, or black. It uses D3 v6 with `csv`, `scaleLinear`, `extent`, `axisLeft`, and `axisBottom` to load data, scale axes, and render an SVG scatter plot. Circles are positioned on the x- and y-scales, with the underlying sepal measurements stored as `rx` and `ry` attributes. The visualization fills the browser window and includes labeled tick marks with enlarged font sizes.

Loading thumbnail…

Fork of Iris Dataset Scatter Plot

This example visualizes the Iris Dataset, plotting petal length against petal width for three iris species, each colored blue, red, or black. It uses D3 v6 with `csv`, `scaleLinear`, `extent`, `axisLeft`, and `axisBottom` to load data, scale axes, and render an SVG scatter plot. Circles are positioned on the x- and y-scales, with the underlying sepal measurements stored as `rx` and `ry` attributes. The visualization fills the browser window and includes labeled tick marks with enlarged font sizes.

Loading thumbnail…

Fork of ICE-6: Rendering Marks and Channels with React & D3

This example shows a horizontal bar chart of the top 20 countries by population, using React to render SVG marks and D3 to compute scales and tick values. The component fetches CSV data from a GitHub gist, parses population values, and maps countries to a band scale along the y-axis and population to a linear scale on the x-axis. The visualization displays gridlines, axis labels, and rectangles for each country, with d3.csv for loading and d3.scaleBand and d3.scaleLinear for positioning.

Loading thumbnail…

Fork of ICE-6: Rendering Marks and Channels with React & D3

This visualization displays COVID-19 data for 20 countries as a horizontal bar chart, with each bar’s length encoding the reported case count. Built using React and D3 v5, it loads CSV data via `d3.csv` and renders SVG elements. Scales are created with `d3.scaleBand` for the y-axis and `d3.scaleLinear` for the x-axis, while gridlines and tick labels are drawn manually using React components. The chart updates asynchronously as data loads, showing a “Loading...” message initially.

Loading thumbnail…

Fork of ICE-6: Rendering Marks and Channels with React & D3

This bar chart displays the top 20 countries with the highest number of Corona cases, using data pulled from a CSV file hosted on GitHub. The visualization renders as an SVG via React components, with D3.js v5 handling the data loading through `d3.csv` and the `scaleBand` and `scaleLinear` functions for positioning and sizing the rectangles. The chart includes axis ticks and labels generated programmatically, with blue vertical gridlines marking each x-axis value.

Loading thumbnail…

Fork of Fork of Fork of ICE-5: Loading and Parsing CSV Data with D3.js

This visualization demonstrates how to load and parse CSV data with D3.js, displaying a bar chart of population figures for the top ten countries from a GitHub-hosted ICE-5 dataset. It uses `d3.csv` to fetch and parse the data, `scaleBand` for the categorical y-axis, `scaleLinear` for the numeric x-axis, and SVG `rect` elements for rendering bars. The page also includes a text overlay reporting file size, row count, and column count.

Loading thumbnail…

Fork of Fork of ICE-5: Loading and Parsing CSV Data with D3.js

This example demonstrates how to load and parse a CSV file from a remote URL using D3.js’s `d3.csv` method, displaying a summary message about the data size, row count, and column count. The visualization also includes a bar chart rendered in React with SVG, using D3’s `scaleBand` and `scaleLinear` to map country names and 2019 population values. The page shows both the raw data statistics and a graphical representation of the first ten rows from the ICE-5 dataset.

Loading thumbnail…

Fork of ICE-5: Loading and Parsing CSV Data with D3.js

This visualization demonstrates how to load and parse CSV data using D3.js. It displays a header and a message container that reports the data size in kilobytes, the number of rows, and the number of columns. The page also includes an embedded SVG image. The code uses the D3.js library’s `d3.csv` method to fetch data from a GitHub Gist URL, then applies `d3.csvFormat` to calculate the data size.

Loading thumbnail…

Fork of ICE-5: Loading and Parsing CSV Data with D3.js

This example demonstrates how to load and parse CSV data using D3.js, presenting a summary of the dataset’s size, row count, and column count in a styled HTML page. The code fetches a remote CSV file via `d3.csv`, processes the resulting array, and displays the statistics using `d3.csvFormat` to measure the data’s kilobyte size. The page also includes a static SVG illustration, while CSS styles the text output. The visualization focuses on the parsing workflow rather than graphical encoding, using D3 v7 within a React project.

Loading thumbnail…

Fork of HTML Starter

This fork demonstrates a minimal HTML page rendering the text “Hello HTML!” in a large, centered font. It uses plain CSS for styling and embeds JavaScript directly in the page to structure the message. The example relies on basic DOM elements and the `style` attribute, without any external libraries or data processing.