Skip to main content
Log in
D

DINESH SAI BOPPANA

@DINESHSAIBOPPANA·48 public vizzes

Loading thumbnail…

Family Network graph

This example shows a family network graph, visualizing eight individuals as labeled nodes and their relationships as weighted links. The force-directed layout uses `d3.layout.force` from D3 v4 to position nodes and edges, with link thickness proportional to a weight value. Red links and orange text labels render in SVG, while node circles are filled blue. The data comes from a static JSON file, and the graph is interactive through `force.drag` for node repositioning.

Jul 9, 2022
Loading thumbnail…

Family Network graph

This example visualizes a family network as a force-directed graph, with eight named nodes connected by weighted links that represent relationships. The code uses D3 v4’s `d3.layout.force` to compute node positions and render the structure as an SVG, drawing red links with stroke widths proportional to each link’s `weight` value. Node labels appear in orange text with blue circles, and interactive dragging is enabled via `force.drag`. Data is loaded from an external `data.json` file, which defines the nodes and their connection weights.

Jul 9, 2022
Loading thumbnail…

Family Tree

A family tree visualization renders hierarchical relationships as an SVG diagram. Colored circles mark each person, with blue, yellow, and orange indicating their depth in the tree, while curved paths connect parents to children. The example uses D3 v5, but notably relies on the missing `d3.stratify` and `d3.tree` APIs, which are not part of the standard D3 library. The code manually positions nodes and links using the x and y coordinates from those undefined functions, with hard-coded data listing individuals and their parents.

Jul 9, 2022
Loading thumbnail…

Fork of ICE 8 - Family Tree

This family tree visualization displays a hierarchical genealogy of nine individuals, with nodes color-coded by generation depth (red for the root, blue for children, green for grandchildren). The code uses `d3.stratify()` to transform the flat parent-child data structure, then `d3.tree()` computes node positions. SVG circles represent nodes, cubic Bézier paths connect parent-child relationships, and text labels identify each person. The coloring function `marker(d.depth)` distinguishes generations, with hardcoded sample data stored as objects with `child` and `parent` properties.

Jul 9, 2022
Loading thumbnail…

Map

This example displays a choropleth map of Indian states, with each state filled by a distinct categorical color and labeled with its name. It uses D3 v4's `d3.geoPath` with the `d3.geoMercator` projection to render SVG paths from TopoJSON data, and `d3.scaleOrdinal` with `schemeCategory10` for coloring. State labels are positioned using the path generator's centroid method. The map also generates tooltips via appended `title` elements, loading geographic data from a remote TopoJSON source.

Jul 9, 2022
Loading thumbnail…

Map

This map displays the United States with each state filled in orange on a blue background. Using the Albers equal-area conic projection, the visualization renders state boundaries from the us-atlas TopoJSON dataset via `d3.geoPath` and `topojson.feature`, with the SVG drawn inside a React application. The map uses a thin gray stroke for state borders and is centered within the viewport through a translate transform.

Jul 9, 2022
Loading thumbnail…

Fork of Fork of Fork of Fork of ICE 8 country map

This visualization displays a choropleth map of India, with individual states filled using an ordinal color scale. The map is rendered as SVG paths generated via `d3.geoPath` and a Mercator projection, with the geographic data parsed from a TopoJSON file using the `feature` function. The code also integrates zoom and pan functionality from D3 v5, and applies a hover effect through CSS to highlight state boundaries.

Jul 9, 2022
Loading thumbnail…

Fork of Fork of Fork of ICE 8 country map

This choropleth map displays Indian states, colored using a categorical scale based on interpolated attributes. The visualization uses D3 v5 with a Mercator projection and SVG rendering, loading state boundaries from a TopoJSON file hosted on GitHub. The code employs `d3.json`, `geoMercator`, `geoPath`, and `scaleOrdinal` with `schemeCategory10` to fill each state path. Interactive hover effects are defined in CSS, though the map itself does not implement zooming or panning. The viewport dimensions drive the SVG size, with a custom translate and scale applied to the projection.

Jul 9, 2022
Loading thumbnail…

Fork of Fork of ICE 8 country map

This example displays a choropleth map of India, with each state rendered as an SVG path and filled using a categorical color scale from `d3.scaleOrdinal` and `schemeCategory10`. The map is generated from TopoJSON data loaded from a GitHub gist, and the geographic paths are computed using `d3.geoMercator` and `d3.geoPath`. The visualization also incorporates a zoom interaction via `d3.zoom`, though no zoom behavior is explicitly attached to the paths. Hover effects are defined in CSS, though the fill property uses an invalid value.

Jul 9, 2022
Loading thumbnail…

Fork of ICE 8 country map

This example renders a choropleth map of India using a Mercator projection, with each state filled by a categorical color scale. The visualization loads GeoJSON data from a TopoJSON file hosted on GitHub, then applies `d3.geoPath` to draw the state boundaries as SVG paths. The code uses `d3.zoom` and `d3.event` for interactivity, and `d3.scaleOrdinal` with `d3.schemeCategory10` for coloring. The map includes a static title and uses `d3.geoMercator` with manual translation and scale settings.

Jul 9, 2022
Loading thumbnail…

Fork of India Map: ICE-8

This visualization displays a choropleth map of Indian states, colored with a categorical scheme and labeled with state names at their geographic centroids. Using D3 v5, it loads TopoJSON data for India’s administrative boundaries, removes the first feature, and projects the geometry with `geoMercator`. Paths are generated via `d3.geoPath`, while text labels are positioned using `pathGenerator.centroid`. The SVG rendering includes hover titles and a color scale from `scaleOrdinal(schemeCategory10)`, with styling applied through CSS.

Jul 9, 2022
Loading thumbnail…

Portland Map

This visualization shows a map of Portland neighborhoods using a conic equal-area projection, rendered as stroked SVG paths. It uses `d3.geoPath` to project and draw the neighborhood boundaries from TopoJSON data, with the geographic projection centered on Portland. The map is displayed in a React component that fetches and parses the data via `d3.json` and `topojson.feature`. The styling applies a teal stroke to the paths, creating a clean, minimal map view.

Jul 9, 2022
Loading thumbnail…

World Map

This visualization displays a world map using a natural Earth projection. The map renders continents and countries as pink shapes with thin black borders on a light blue sphere background, providing a clear geographic overview. The code uses D3 v5 functions including `d3.geoPath` and `d3.geoNaturalEarth1` to project and draw the map, while the TopoJSON library’s `feature` method extracts country boundaries from the world-atlas dataset. The SVG output is generated with D3’s selection and attribute APIs, and the sphere and country paths are styled using CSS classes.

Jul 8, 2022
Loading thumbnail…

World Map with D3.js!

This example displays a world map as an SVG, with pink countries outlined in red against a blue spherical backdrop. It uses d3.geoNaturalEarth1 for the projection and d3.geoPath to generate paths from TopoJSON data loaded from the world-atlas package. A sphere path is drawn first, followed by country features from the dataset. Hovering over a country changes its fill color, demonstrating basic interactivity within a D3 v5 workflow.

Jul 8, 2022
Loading thumbnail…

ICE Bonus

A three-dimensional scatter plot displays the relationship between height, weight, and age for individuals in a dataset. Each point represents a person, with size and opacity fixed, while colored markers show the three variables on the x, y, and z axes. The visualization uses Plotly’s `newPlot` function to render the `scatter3d` trace, and D3’s `d3.csv` method loads the data from a remote GitHub gist. The layout margin is set to zero for a clean, focused view.

Jul 8, 2022
Loading thumbnail…

3D chart

This 3D bar chart visualizes the top 10 countries most affected by COVID-19, comparing Age and Height metrics for each nation. The visualization uses the d3.x3d library to render an interactive three-dimensional bar chart, with data loaded from a CSV file hosted on GitHub. The implementation combines d3.csv for data parsing, d3.scaleLinear for value mapping, and the d3-x3d chart component to generate the 3D scene, which is displayed within an HTML div element using the X3DOM framework.

Jul 8, 2022
Loading thumbnail…

Fork of World Map with D3.js!

This example displays a world map as an SVG graphic, with each country rendered as a green path with black outlines. Hovering over a country changes its fill color to orange, providing basic user feedback. The visualization uses D3 v5 functions such as `select`, `json`, `geoPath`, and `geoEquirectangular` for the projection, while TopoJSON’s `feature` method converts the loaded world-atlas countries-110m.json data into GeoJSON features for rendering.

Jul 7, 2022
Loading thumbnail…

Fork of World Map with D3.js!

This example displays a world map as an SVG graphic, with each country rendered as a green path with black outlines. Hovering over a country changes its fill color to orange, providing basic user feedback. The visualization uses D3 v5 functions such as `select`, `json`, `geoPath`, and `geoEquirectangular` for the projection, while TopoJSON’s `feature` method converts the loaded world-atlas countries-110m.json data into GeoJSON features for rendering.

Jul 7, 2022
Loading thumbnail…

Fork of World Map with D3.js!

This example displays a world map as an SVG graphic, with each country rendered as a green path with black outlines. Hovering over a country changes its fill color to orange, providing basic user feedback. The visualization uses D3 v5 functions such as `select`, `json`, `geoPath`, and `geoEquirectangular` for the projection, while TopoJSON’s `feature` method converts the loaded world-atlas countries-110m.json data into GeoJSON features for rendering.

Jul 7, 2022
Loading thumbnail…

World Map with D3.js!

This visualization displays a world map with countries rendered as pink shapes outlined in red against a blue spherical background. It uses d3-geoPath with an equirectangular projection to draw geographic features, and topojson's feature method to extract country polygons from the Natural Earth dataset loaded via world-atlas. The sphere background is created by passing a Sphere geometry object to the same path generator. Hovering highlights individual countries by changing their fill color.

Jul 7, 2022
Loading thumbnail…

World Map with D3.js!

This example displays a world map rendered as an SVG using D3 version 5 and TopoJSON, with the geographic projection and path generation handled by d3.geoPath. The page loads world topology data and draws country boundaries onto a 960-by-500-pixel canvas. It serves as a basic demonstration of integrating D3’s mapping utilities with external TopoJSON data to produce an interactive-ready visualization.

Jul 7, 2022
Loading thumbnail…

Android Users Data chat

An area chart tracks the number of Android users over a series of years, with the curve filled in orange and axes labeled "users" and "Years." The visualization uses D3 v6 to load CSV data, parse dates with `d3.timeParse`, and render an SVG. It applies `d3.scaleTime` and `d3.scaleLinear` for the axes, `d3.area` with `curveBasis` for the smoothed area path, and custom tick formatting to display billions. The data originates from a GitHub gist.

Jul 4, 2022
Loading thumbnail…

Data of Electronic sales line chart

This line chart displays electronic sales totals over time, using a multi-year date range on the x-axis and cumulative sales figures on the y-axis. The visualization loads CSV data from a GitHub gist and renders a single black trend line in an SVG canvas. It employs D3 v5 APIs including `scaleTime`, `scaleLinear`, `axisBottom`, `axisLeft`, and `line` to generate axes with grid ticks and the path. The chart labels both axes and uses a skyblue background from its stylesheet.

Jul 4, 2022
Loading thumbnail…

AUTO SALES OF Pie Chart

This pie chart displays 2022 US auto sales by brand, showing each company’s market share as a percentage and sales volume in thousands. Built with D3 v5, it loads CSV data from a GitHub gist and uses `d3.pie` and `d3.arc` to generate SVG paths, with `d3.scaleOrdinal` assigning colors to each segment. The visualization renders a legend with color swatches, brand names, percentage values, and sales figures, all formatted using `d3.format`.

Jul 4, 2022
Loading thumbnail…

D3 Scatter Plot

This D3.js scatter plot visualizes the Iris dataset, showing different flower measurements as points across a continuous animation. The chart cycles through four attribute combinations—petal width, sepal width, petal length, and sepal length—every two seconds, smoothly re-rendering axes and circles via the `scatterPlot` reusable chart API. It uses d3's `scaleLinear`, `extent`, `axisLeft`, `axisBottom`, and SVG `join` operations for declarative updates, while styling text with the Share Tech font.

Jul 4, 2022
Loading thumbnail…

Reusable D3 Scatter Plot

This interactive scatter plot displays the Iris dataset, with each circle representing a flower sample. The visualization cycles through different column pairs every two seconds, animating between petal width, sepal width, petal length, and sepal length on the x-axis while keeping sepal length fixed on the y-axis. Built with D3.js v6, it uses `scaleLinear`, `extent`, `axisLeft`, and `axisBottom` to map data to SVG circles, demonstrating a reusable chart pattern where the same plot function is called repeatedly with updated accessors.

Jul 4, 2022
Loading thumbnail…

D3 Scatter Plot

This D3 scatter plot visualizes the Iris Dataset, mapping petal length on the x-axis against sepal length on the y-axis. Each flower is represented by a circle, with scales derived from the data’s extent using d3.scaleLinear. The SVG rendering uses d3.select and .join() to create the circles, while d3.axisLeft and d3.axisBottom generate the labeled axes. Data is loaded asynchronously via d3.csv, and the plot fills the browser window, with margins and a fixed radius applied to all points.

Jul 4, 2022
Loading thumbnail…

Fork of D3 Scatter Plot

A D3 scatter plot displays the Iris dataset, mapping petal length on the x-axis and sepal length on the y-axis. Each flower is represented as a circle with a fixed radius of 5 pixels. The visualization uses `d3.csv` to load the data, `d3.scaleLinear` for both axes, and `d3.extent` to compute the domains. Axes are rendered with `d3.axisLeft` and `d3.axisBottom`, with the SVG filling the full browser window. The chart is built using D3 v6 and styled with a 24-pixel tick font.

Jul 4, 2022
Loading thumbnail…

Fork of Fork of Fork of Stylized Scatter Plot with Color Legend

This scatter plot visualizes the Iris Dataset, showing the relationship between petal width and sepal length for different iris species. Each circle represents a flower, color-coded by species using a categorical color scale. The visualization uses d3.v5 to create SVG output, with axes and a color legend rendered via d3.legendColor. Data is loaded from a remote CSV file using d3.csv, and scales are defined with d3.scaleLinear and d3.scaleOrdinal.

Jun 29, 2022
Loading thumbnail…

Fork of Scatter Plot Using Iris Data

This scatter plot visualizes the Iris dataset, mapping petal length and width on the x- and y-axes. Points are colored by species using a switch statement, with setosa, versicolor, and virginica shown in orange, green, and purple. The code loads CSV data via `d3.csv`, uses `scaleLinear` and `extent` for scales, and renders circles with SVG attributes. Axis labels and tick text are styled with custom fonts, and the plot fills the browser window.

Jun 27, 2022
Loading thumbnail…

population of countries ICE-5

This bar chart shows the population of the top 10 most populous countries, using 2018 estimates from the United Nations World Population Prospects. The chart displays population values on the x-axis and country names on the y-axis, with each bar colored steelblue and axis labels featuring custom formatting that abbreviates large numbers. The visualization is built with D3 v5, using `scaleLinear` and `scaleBand` for the axes, `axisBottom` and `axisLeft` for tick marks, and SVG rendering for the output. Data is loaded from a local CSV file, with population values multiplied by 1000 before rendering.

Jun 23, 2022
Loading thumbnail…

Fork of Customizing Axes

This bar chart displays the population of the top 10 most populous countries using 2018 estimates from the United Nations World Population Prospects. The visualization demonstrates custom axis styling with D3.js v5, including formatted tick labels (converting G to B for billions), removed domain lines, and styled tick marks. It uses `d3.scaleLinear` for the x-axis, `d3.scaleBand` for the y-axis, and `d3.axisBottom` with a custom tick formatter via `d3.format`. The SVG rendering includes a title and axis label, with country names on the left.

Jun 23, 2022
Loading thumbnail…

Fork of Electric Bar Chart Using d3.stack

This stacked bar chart visualizes two years of personal electricity consumption across multiple accounts in a three-family building. The visualization uses d3.stack to layer consumption by account number for each monthly reading, with green and blue color encoding distinguishing accounts. Built with d3-scaleBand, d3-scaleLinear, and d3-scaleOrdinal, the chart renders as SVG with animated hover effects that adjust bar opacity and display tooltips showing kilowatt-hour values. The code imports data via d3.csv and utilizes d3-scale-chromatic for the color scheme.

Jun 23, 2022
Loading thumbnail…

Fork of Filtered Stacked Line Graph and Donut Graph of Deaths with Legend

This interactive React visualization displays mortality data for suicide, firearm, and alcohol-related deaths across demographic categories using stacked area charts and a donut graph. The main chart shows temporal trends filtered by sex, ethnicity, and age group, while a pie chart breaks down proportional death types. Built with D3 v5, it employs d3.area() with curveNatural for smooth transitions, d3.pie() and d3.arc() for the donut, and scales like scaleLinear and scaleOrdinal. Hover interactions on the color legend fade non-selected categories, with data sourced from a Gist CSV file.

Jun 23, 2022
Loading thumbnail…

Fork of AVN - ICE5

This horizontal bar chart displays IPL winners and their prize money in millions of dollars, with winning teams on the y-axis and prize values on the x-axis. The visualization uses d3.csv to load data from a gist URL, then applies d3.scaleBand and d3.scaleLinear to map team names and prize amounts. The SVG rendering uses d3.select, d3.axisBottom, and d3.axisLeft to construct the chart, with d3.format customizing tick labels. Rectangles filled with steelblue represent the data, while a title and axis label annotate the graphic.

Jun 23, 2022
Loading thumbnail…

Dinesh sai boppana

This bar chart displays the winners of the Indian Premier League and their prize money in millions of dollars, with teams on the y-axis and prize amounts on the x-axis ranging from 0 to 15. The visualization uses D3 v5’s `scaleLinear` and `scaleBand` to map data, with `axisBottom` and `axisLeft` generating the axes. Data is loaded from a CSV file via `d3.csv`, and the chart is rendered as SVG elements, with the title and axis labels added as text.

Jun 23, 2022
Loading thumbnail…

Fork of Stylized Bar Chart

This bar chart displays the top 10 most populous countries for 2020, ranked along the vertical axis with population counts on the horizontal axis. Built with React and D3 v5, it uses `d3.csv` to load United Nations World Population Prospects 2019 data, `d3.scaleBand` for the categorical country axis, and `d3.scaleLinear` for population values. SVG rectangles render the bars, with axis components custom-built as React functions and formatted tick labels using `d3.format`. Hovering shows a native tooltip with the population value.

Jun 22, 2022
Loading thumbnail…

Fork of Fork of ICE-6 Tutorial Bar Chart

This horizontal bar chart displays the top 10 cosmetic products by revenue, with each bar’s length proportional to its dollar value. The visualization uses D3 v5, employing `scaleLinear` and `scaleBand` to map revenue and product names, while `axisLeft` and `axisBottom` render the axes. Data is loaded via `d3.csv` from a remote GitHub gist, and the chart is drawn as SVG elements with a custom tick formatter that abbreviates large numbers.

Jun 22, 2022
Loading thumbnail…

Fork of ICE-6 Tutorial Bar Chart

This bar chart displays the top 10 cosmetic products by revenue in dollars, using a horizontal layout with a linear x-scale and a banded y-scale. The visualization is built with D3 v5, leveraging the `scaleLinear`, `scaleBand`, `axisBottom`, and `axisLeft` APIs to render axes and bars. Data is loaded from a CSV file via `d3.csv`, with revenue values parsed as numbers. The chart includes axis labels and custom tick formatting that converts large numbers from G to B. The SVG canvas is 860 by 450 pixels, with margins arranged for clear presentation.

Jun 22, 2022
Loading thumbnail…

Fork of Fork of Making a Bar Chart

A horizontal bar chart displays the population of the ten most populous countries, with values from a 2018 United Nations estimate scaled by a factor of one thousand. The visualization uses d3.csv to load the dataset, then applies d3.scaleLinear for the x-axis and d3.scaleBand for the categorical y-axis. SVG rectangles are bound to the data, and axes are rendered using d3.axisLeft and d3.axisBottom, with the chart drawn within a fixed 960×500 SVG viewport.

Jun 22, 2022
Loading thumbnail…

Fork of Making a Bar Chart

This bar chart displays the population of the ten most populous countries, based on 2018 estimates from the United Nations World Population Prospects. It uses d3.csv to load the data, then renders horizontal bars with d3.scaleLinear for the x-axis and d3.scaleBand for the y-axis. The chart applies d3.axisLeft and d3.axisBottom for labeling, and draws the bars as SVG rectangles with a steelblue fill.

Jun 22, 2022
Loading thumbnail…

Fork of Loading and Parsing football results Data

This visualization displays summary statistics from a CSV file containing international football match results, including FIFA World Cup games. It shows the file size in kilobytes, the number of rows, and the number of columns in the dataset. The code uses d3.csv to load and parse the external CSV file, then d3.csvFormat to calculate the data size. A large <pre> element presents the three metrics as plain text, with the computation handled through D3 v5's promise-based API.

Jun 22, 2022
Loading thumbnail…

Fork of Let's make a face with D3.js

This example renders a stylized face using D3.js v5 within a React framework, displayed as scalable vector graphics with animated eyebrows. A yellow circle forms the head, with two smaller circles for eyes and a path-based arc for the mouth. The code uses D3’s `select` and `append` to build the SVG structure, `arc()` to generate the mouth path, and chained `.transition().duration()` calls to animate the eyebrow rectangles vertically over two seconds each, creating a subtle bobbing motion. The animation runs in an HTML page that loads D3 from a CDN.

Jun 21, 2022
Loading thumbnail…

Fork of Let's make a face with D3.js

This example renders a stylized face using D3.js v5 within a React framework, displayed as scalable vector graphics with animated eyebrows. A yellow circle forms the head, with two smaller circles for eyes and a path-based arc for the mouth. The code uses D3’s `select` and `append` to build the SVG structure, `arc()` to generate the mouth path, and chained `.transition().duration()` calls to animate the eyebrow rectangles vertically over two seconds each, creating a subtle bobbing motion. The animation runs in an HTML page that loads D3 from a CDN.

Jun 20, 2022
Loading thumbnail…

Fork of Let's make a face with D3.js

This example renders a stylized face using D3.js v5 within a React framework, displayed as scalable vector graphics with animated eyebrows. A yellow circle forms the head, with two smaller circles for eyes and a path-based arc for the mouth. The code uses D3’s `select` and `append` to build the SVG structure, `arc()` to generate the mouth path, and chained `.transition().duration()` calls to animate the eyebrow rectangles vertically over two seconds each, creating a subtle bobbing motion. The animation runs in an HTML page that loads D3 from a CDN.

Jun 20, 2022
Loading thumbnail…

Fork of Let's make a face with D3.js

This example renders a stylized face using D3.js v5 within a React framework, displayed as scalable vector graphics with animated eyebrows. A yellow circle forms the head, with two smaller circles for eyes and a path-based arc for the mouth. The code uses D3’s `select` and `append` to build the SVG structure, `arc()` to generate the mouth path, and chained `.transition().duration()` calls to animate the eyebrow rectangles vertically over two seconds each, creating a subtle bobbing motion. The animation runs in an HTML page that loads D3 from a CDN.

Jun 20, 2022
Loading thumbnail…

Fork of Fork of Let's make a face with D3.js

This example animates a cartoon face built from basic SVG shapes, with eyebrows that move up and down over time to create a playful expression. The face consists of a yellow circle for the head, two black-outlined eyes, and a mouth drawn as a curved arc. The code uses D3.js v5 to construct and manipulate the SVG elements, and leverages D3's `transition()` method to animate the vertical position of the eyebrows. The static parts of the face (head, eyes, mouth) are defined with D3's `select` and `append` APIs, while the mouth is generated with `d3.arc`. The animation runs in a continuous loop, making the face appear to raise and lower its brows indefinitely.

Jun 20, 2022
Loading thumbnail…

Fork of Let's make a face with D3.js

This example renders a stylized face using D3.js v5 within a React framework, displayed as scalable vector graphics with animated eyebrows. A yellow circle forms the head, with two smaller circles for eyes and a path-based arc for the mouth. The code uses D3’s `select` and `append` to build the SVG structure, `arc()` to generate the mouth path, and chained `.transition().duration()` calls to animate the eyebrow rectangles vertically over two seconds each, creating a subtle bobbing motion. The animation runs in an HTML page that loads D3 from a CDN.

Jun 20, 2022