L

LakshmanRangisetti

@LakshmanRangisetti·31 public vizzes

Loading thumbnail…

Social Network Graph

This interactive social network graph visualizes friendships among seven people using a force-directed layout. The D3.js visualization renders nodes as orange circles with name labels and directed arrows for edges, showing connections like David's links to Emma, James, Oliver, Sophia, and Liam. The graph uses `d3.forceSimulation` with link, charge, collision, and center forces to position nodes dynamically. Users can drag nodes to rearrange the network, with hover effects highlighting individual nodes. The example demonstrates D3 v6 imports via UNPKG, JSON data loading, and SVG rendering with mouse event handlers and drag behavior.

Loading thumbnail…

Stacked Bar Chart

This stacked bar chart displays the religious composition of populations across multiple countries, using one bar per country segmented by religion and scaled by population. The visualization loads D3 v3 via CDN, builds the stacked layout with `d3.layout.stack`, and applies ordinal and linear scales for axes. Interactive features include tooltips via d3-tip and a color legend that filters bars on hover, with an overlay rectangle controlling transparency transitions.

Loading thumbnail…

Tree Chart

An animated hierarchical tree chart displays a dataset of continents, countries, cities, and local landmarks, with nodes color-coded by level: black for roots, blue for countries, red for cities, and green for landmarks. The visualization uses D3.js version 3 layout and diagonal SVG paths, with an in-memory JSON array as the data source. Transitions animate the tree’s expansion, while styling from CSS handles node circles and text.

Loading thumbnail…

United Kingdom - Country Map

This example displays a choropleth map of the United Kingdom using a green fill with black borders. It loads geographic data from the world-atlas TopoJSON file, extracts the United Kingdom feature, and projects it with a Mercator projection using `d3.geoMercator` and `d3.geoPath`. The map is rendered as an SVG path element within a 960×500 canvas, with data fetched via `d3.json`.

Loading thumbnail…

Reusable Scatter Plot

This interactive scatter plot visualizes penguin measurements, cycling through different feature pairs on the x-axis with a timed animation. Built with D3.js, it uses an ES6 module (scatterPlot.js) to define a reusable chart component. The plot colors points by species (Adelie, Gentoo, Chinstrap) using D3's `scaleLinear` and `axisLeft`/`axisBottom` APIs, and loads data from a remote CSV file via `d3.csv`. The SVG rendering includes a legend and axis labels, with the animation triggered by `setInterval`.

Loading thumbnail…

World Map Visualization

This example displays a world map using D3’s `geoNaturalEarth1` projection, coloring each country by its economy classification from a TSV dataset. It loads geographic data from `world-atlas` GeoJSON and joins it with metadata, then renders countries as SVG paths with a blue ordinal color scale. The map supports zooming and panning via `d3.zoom`, and features a hover effect that highlights countries in orange.

Loading thumbnail…

Bubble Chart

This bubble chart compares cereal manufacturers by plotting each product’s sodium level on the x-axis, its rating on the y-axis, and its calorie count as the bubble radius. Manufacturers are distinguished by color using `d3.scaleOrdinal` with the `d3.schemeSet1` palette. The code loads data from a CSV file, builds the visualization with SVG, and includes legends for both bubble size and color. All axes, scales, and labels are created using standard D3 v7 methods such as `d3.scaleLinear` and `d3.axisBottom`.

Loading thumbnail…

Scatter Plot

This scatter plot visualizes penguin measurements, mapping flipper length to the x-axis, body mass to the y-axis, and coloring each point by species (Adelie, Gentoo, and Chinstrap). The code loads data from a CSV URL using `d3.csv`, then uses `d3.scaleLinear`, `d3.extent`, `d3.axisLeft`, and `d3.axisBottom` to build the axes. SVG circles are appended to the DOM with radius and fill attributes derived from bill dimensions and species, respectively.

Loading thumbnail…

Bar Chart

This bar chart displays the elevations of the 20 highest mountain peaks, with the Y-axis listing mountain names and the X-axis showing elevation in feet. Built with React and D3 v5, it uses `scaleBand` for the categorical Y-axis, `scaleLinear` for the numeric X-axis, and `format` to abbreviate tick labels. Data loads asynchronously from a CSV file via `d3.csv`, and SVG rectangles render each bar with a native `<title>` element for tooltips.

Loading thumbnail…

Network Graph

This example shows a social network graph where ten people are connected by friendship links. The force-directed layout positions nodes and edges, with the thickness of the blue lines indicating the strength of the relationship, such as the stronger connection between MY3 and Sudha. The visualization is built with the D3 library, using `d3.forceSimulation` to handle the physics of the node placement, along with `d3.forceLink`, `d3.forceManyBody`, and `d3.forceCollide` to manage the layout. Node elements are created as SVG groups with circles and text labels, and the graph supports interactive dragging. The data comes from a local `graph.json` file which provides both the network structure and the relationship values.

Loading thumbnail…

MuscleCars tree

This interactive tree diagram visualizes a hierarchy of muscle car models, starting with a root "Muscle Cars" node that branches into Ford and Dodge, then into specific models like Mustang, Charger, and Hellcat. The layout uses d3.layout.tree to arrange nodes, with each node color-coded by its type level and rendered as SVG rectangles with drop shadows. Users can click nodes to collapse or expand branches, while links display text labels and directional arrows. The visualization also includes zoom and drag behavior via d3.behavior.zoom, with data loaded from a JSON file.

Loading thumbnail…

Activity 8 Country

This example displays a map of India using a Mercator projection, rendered as an SVG path. It loads country boundary data from the world-atlas TopoJSON file hosted on jsDelivr, then extracts India’s geometry with `topojson.feature`. The code uses `d3.geoMercator` and `d3.geoPath` to project and draw the shape, fitting it to a 960×500 viewport via `fitSize`.

Loading thumbnail…

Activity 8 Map

This interactive world map uses D3.js to render country boundaries from the world-atlas TopoJSON data. The visualization displays continents in light green with indigo borders against a skyblue ocean sphere using an equirectangular projection. The map supports pan and zoom interactions through D3's zoom and event APIs, while hover states are implemented via CSS to change country colors to maroon. The code demonstrates importing D3 modules and a local ES6 module, and uses the topojson library's feature method to convert the data into GeoJSON.

Loading thumbnail…

Area Chart Activity 8

This area chart displays the cost of sales from 2000 to 2013 using a smooth, basis-curved line and a light green filled region beneath it. The visualization uses D3 v5 to load CSV data from a GitHub repository, parse year strings into Date objects, and render axes with red tick labels and orange axis labels. The chart employs `scaleTime`, `scaleLinear`, `axisLeft`, `axisBottom`, `line`, `area`, and `curveBasis` to generate the SVG output, with a formatted y-axis tick scale using `format`.

Loading thumbnail…

linechart

This example visualizes the cost of sales from 2000 to 2013 using a line chart rendered as an SVG. The chart is built with D3 v7, loading data from a local CSV file that contains two columns: year and cost. The code defines a band scale for the x-axis and a linear scale for the y-axis, then draws a light green line connecting the data points. Custom axis labels for "Year" and "cost" are added in red, and the chart includes styled tick text and a title.

Loading thumbnail…

Pie Chart

This D3 pie chart visualizes the count of students per major at UNT, using a dataset loaded from a GitHub-hosted CSV file via `d3.csv`. The chart uses `d3.pie` and `d3.arc` to generate SVG arcs, with colors assigned via `d3.scaleOrdinal`. Each slice displays its value in thousands, and a legend lists majors alongside their counts. The visualization is framed by a red title and rendered in an SVG canvas, with styling applied through CSS classes.

Loading thumbnail…

Reusable Scatter plot Activity 8

This interactive scatter plot animates through different Iris flower measurements, cycling the x-axis between petal width, sepal width, petal length, and sepal length every few seconds. It uses D3 v6 to load CSV data asynchronously, render SVG circles colored by species, and update scales and axes via a reusable `scatterPlot` module. The visualization includes axis labels, a species legend, and a title, demonstrating dynamic data binding with `selectAll`/`join` and interval-driven transitions.

Loading thumbnail…

Reusable Scatter plot Activity 8

This interactive scatter plot visualizes the Iris dataset, displaying relationships between sepal and petal measurements. It cycles through different x-axis variables (petal width, sepal width, petal length, sepal length) in an animation, with each species point colored distinctly (skyblue, lightgreen, orange). The D3-based implementation loads data via `d3.csv`, uses a custom `scatterPlot` module that leverages `scaleLinear`, `extent`, `axisLeft`, and `axisBottom` to build the axes, and renders the animated transitions via `setInterval` and the `join` API for circles.

Loading thumbnail…

Assignment 1-Task10

This example loads a dataset from a GitHub gist and displays the first 10 rows as formatted JSON text. The visualization uses D3 v5, specifically the `csv` function to parse the remote data and the `select` function to append `<pre>` elements to the body. The rendered output is plain text within an SVG container, with custom CSS styling applied to the text elements. The code demonstrates importing D3 utilities and handling asynchronous data loading with a Promise chain.

Loading thumbnail…

Bubble chart

This bubble chart explores the correlation between average torque, horsepower, and highway MPG across 31 car makes. Each circle’s position encodes horsepower (x-axis) and torque (y-axis), while its radius scales with highway MPG and its color maps to the car make. A tooltip reveals the make name on hover. The visualization uses D3 v7 with SVG rendering, linear scales, and animation, pulling data from a remote CSV file. A legend displays MPG values (20, 40) as reference circles, and color swatches identify each make.

Loading thumbnail…

Bubble chart

This bubble chart visualizes the correlation between average horsepower (x-axis), torque (y-axis), and highway MPG (bubble size and color) for 31 car makes. Each circle is positioned by its horsepower and torque values, while its radius encodes highway MPG and its color distinguishes the car brand. Rendered as SVG with animation, the chart uses D3.js v7 APIs including `d3.scaleLinear` for axes and bubble sizing, `d3.scaleOrdinal` for color mapping, and `d3.interpolateTurbo` for the color palette. Interactive tooltips appear on mouseover, displaying the car make. The data comes from a CSV file, with a legend explaining the highway MPG bubble sizes.

Loading thumbnail…

bubble chart activity 7

This example demonstrates a bubble chart rendered with D3.js, showing data points as circles with scaled radii. The visualization is built using D3 v5, loaded via UNPKG, and the code imports API functions like `select` to manipulate the DOM. It also showcases local ES6 module imports, with a separate message module controlling text in the page. The chart’s styling is handled through a linked CSS file. The core behavior is minimal, focusing on integrating D3 with modular JavaScript rather than interactive simulation.

Loading thumbnail…

Fork of Scatter Plot with Shape

A scatter plot shows sepal length against petal length for the Iris dataset, with each species represented by a distinct symbol shape and a legend mapping species to shapes. The visualization loads CSV data via `fetch` and `csvParse`, then renders marks using D3’s `symbol`, `scaleLinear`, `scaleOrdinal`, and `symbolsFill`. Axes and labels are added through custom ES6 modules (`axes.js`, `scatterPlot.js`) using `axisLeft`, `axisBottom`, and D3 selections.

Loading thumbnail…

Activity 7 Scatter Plot

This scatter plot visualizes the Iris dataset, mapping petal length and width for three species of iris flowers, with points colored by species: skyblue for setosa, lightgreen for versicolor, and orange for virginica. The code loads CSV data via d3.csv, uses d3.scaleLinear with d3.extent to establish scales, and renders the plot as an SVG. Axes are drawn with d3.axisLeft and d3.axisBottom, while circle elements are bound to the data and positioned using scaled values, with labeled axes for petal and sepal measurements.

Loading thumbnail…

IMDb Movie ratings

This example visualizes the distribution of IMDb movie ratings across genres using a stacked horizontal bar chart. Each bar represents a genre, broken into five rating categories from “below 5.0” to “above 8.5,” with lengths proportional to the percentage of movies in each category. The visualization uses D3 v7’s `d3.stack` and `d3.scaleOrdinal` with custom color assignments, rendered as inline SVG elements. Mouseover interactions trigger a tooltip displaying the exact percentage for each rating segment, while axes and legends are built with `d3.axisBottom` and `d3.axisLeft`.

Loading thumbnail…

Activity 7

This horizontal bar chart displays the 2010 populations of ten countries, sorted by name along the y-axis. The visualization uses React with D3.js v5, constructing an SVG with scales from `d3.scaleBand` and `d3.scaleLinear`. The population values are loaded from a CSV file via `d3.csv`, formatted with `d3.format` (abbreviated to billions), and rendered as green rectangles. Axis tick marks and labels are styled with blue lines and gray text, with a cumulative x-axis label reading "POPULATION-2010".

Loading thumbnail…

Activity 6

This example demonstrates loading CSV data from a GitHub gist and rendering the first ten rows as formatted JSON on the page. It uses D3 v5’s `csv` method to fetch and parse the data, then `select` and `append` to insert text elements into the body. The code also imports `csvFormat` to calculate data size, and includes a local ES6 module exporting a message. Rendering is done with SVG in the HTML.

Loading thumbnail…

BMI by Age

This visualization displays average body mass index (BMI) by age using binned bar chart rectangles over a scatter-style plot. The D3 v7 code loads data from a CSV file, computes BMI from height and weight, and uses d3.bin to group ages. Scales, axes, and labels are generated with d3.scaleLinear, d3.axisBottom, and d3.axisLeft, rendered as SVG with custom tick styling.

Loading thumbnail…

Transforming Data

This example shows the average sepal length for each iris species from a CSV dataset of flower measurements. It first loads the data with `fetch` and parses it using `d3.csvParse`, then groups and aggregates the values with `d3.flatRollup` and `d3.sum`. The resulting summary is rendered as formatted JSON text inside a `pre` element using D3's `select` and data joins. The visualization demonstrates D3 v7 loading via UNPKG and local ES6 module imports.

Loading thumbnail…

Untitled

This example demonstrates how to load D3 via UNPKG and use ES6 module imports with Vue. The page renders an SVG element containing an embedded JPEG image, while the JavaScript uses `select` from D3 to set the text content of an HTML element with a message imported from a local module. The code also includes CSS styling for the message, showing integration between D3, custom modules, and Vue framework.

Loading thumbnail…

buddha

This visualization displays a stylized Buddha figure formed from a dense grid of rotated, randomly colored diamond-shaped polygons rendered in SVG. The composition layers the geometric overlay with a detailed black-and-white line-art path of the Buddha, creating a juxtaposition of abstract digital texture and figurative illustration. Built with React and ReactDOM, the example uses JSX to map over numeric arrays, generating polygon elements with randomized coordinates, fill colors, and rotations via `Math.random()` calls.