M

manvithareddykarra

@manvithareddykarra·35 public vizzes

Loading thumbnail…

ICE-8 Polished World Map

This interactive world map visualizes global country boundaries and graticules, rendered as stylized SVG paths within an artificial "sphere." The visualization pulls geographic data from a World Atlas TopoJSON source, using `d3.geoPath` with the Natural Earth projection to draw landmasses, while `d3.geoGraticule` generates reference lines. The React-based app, built with `d3.json` for data fetching and TopoJSON's `feature` and `mesh` functions, layers distinct visual elements: a light teal sphere, beige land polygons, and muted interior boundaries, all styled via CSS classes for a polished appearance.

Loading thumbnail…

Fork ICE-8 of Swedish map

This visualization shows the counties (län) of Sweden as filled red polygons with teal borders between neighboring regions, rendered as an SVG map. The map uses a Mercator projection fitted to the geographic data. The code loads TopoJSON data from a gist, converts it to GeoJSON using `topojson.feature` and `topojson.mesh`, and draws paths with `d3.geoPath`. The visualization is built with React, using the `useData` hook to fetch and transform the data, and styles the map with classes defined in CSS.

Loading thumbnail…

Fork of ICE 8 Network Graph

This example shows a network graph of family relationships, with a central parent node connected to child nodes and further sub-nodes. The visualization uses D3.js force simulation to position the nodes and links, rendered as SVG circles and lines. The code applies `d3.forceSimulation` with `forceManyBody` for repulsion, `forceLink` for connections, and `forceCenter` to anchor the layout. Node colors and sizes are defined in a separate `colors.js` module, and the data structure is built programmatically in `data.js`.

Loading thumbnail…

Fork of ICE 8 Family Tree

This example renders a family tree as a hierarchical node-link diagram using React and D3 v5. The visualization reads hierarchical data from a JSON file, applying a tree layout (`d3.tree`) and drawing curved links with `d3.linkHorizontal`. Nodes appear as colored labels, with font size scaling by depth and fill color set per node’s data. The SVG supports pan and zoom via `d3.zoom` on the root group.

Loading thumbnail…

Fork of ICE 8 Family Tree

This visualization shows a family tree rendered as a horizontal dendrogram, with each individual displayed as a colored label connected by black links. The tree's structure is derived from a hierarchical JSON data file, and the node fill colors are specified within the data itself, distinguishing generations. Built with React and D3 v5, the code uses `tree()` and `hierarchy()` to compute the layout, `linkHorizontal()` to generate the connecting paths, and a `zoom()` interaction for panning and scaling. Text elements are styled with a Playfair Display font and a white text-shadow on an SVG canvas.

Loading thumbnail…

Fork of ICE 8 Family Tree

This interactive family tree visualization presents hierarchical relationships as a horizontal dendrogram, with root nodes branching outward to descendants. The tree is rendered as SVG using D3 v5’s `tree()` layout and `linkHorizontal()` path generator, while a `zoom()` behavior enables pan and zoom. Node colors and font sizes vary by depth, with labels drawn from a JSON data file. The React framework manages the component, and CSS applies the Playfair Display font and a white text shadow for readability.

Loading thumbnail…

Fork of Swedish map

This visualization displays a map of Swedish counties, rendered as dark filled polygons with teal boundaries between regions. The map uses a Mercator projection fitted to the geographic data. Built with React and D3 v5, the code employs `geoMercator`, `geoPath`, and `fitExtent` to project and scale the map. TopoJSON data is converted to GeoJSON features and meshes using the `feature` and `mesh` functions from the topojson library.

Loading thumbnail…

Fork of Salem Map

This visualization displays the geographic boundaries of Salem, India, as vector paths rendered on a Mercator projection. The map uses the D3 geoMercator and geoPath APIs to transform TopoJSON data, which is processed through the topojson library's feature function to extract the salem_new object. Each region's boundary is drawn as a path element with a red stroke, and the visualization is built using React components that fetch the data from a GitHub Gist.

Loading thumbnail…

Fork of World Map

A world map renders landmasses in teal on a light gray sphere, with graticule lines and country borders overlaid. The visualization uses an orthographic projection via `d3.geoOrthographic` and draws geographic features with `d3.geoPath`. The React component fetches world-atlas TopoJSON data through `d3.json`, converting it to GeoJSON with `topojson.feature` and `topojson.mesh`. Styling is applied through SVG classes, showing a clean, static globe view.

Loading thumbnail…

Fork of ICE 7 Area Chart

This visualization displays the sales of a company in India from 2011 to 2020, combining a smooth line chart with a filled area beneath it to emphasize the trend over time. The chart uses D3 v5 with SVG rendering, employing `d3.line()`, `d3.area()`, and `curveBasis` to generate the paths, along with `d3.scaleTime`, `d3.scaleLinear`, and `d3.axisBottom`/`d3.axisLeft` for scales and axes. Data is loaded from a CSV via `d3.csv` and parsed with `d3.timeParse`.

Loading thumbnail…

ICE 7 Reusable D3 Scatter Plot

This reusable scatter plot, built with D3.js, visualizes the Iris dataset, mapping petal width to the x-axis and sepal length to the y-axis while encoding species with different symbols. The chart updates every 15 seconds, cycling through the four numeric columns for the x-axis. It uses a modular `scatterPlot` function with D3 scales, ordinal symbols, and axes, rendered as SVG, based on the "Towards Reusable Charts" pattern.

Loading thumbnail…

ICE 7 Area Chart

This area chart displays car sales over time, using a smooth curved line to show the trend and an orange filled region beneath it to emphasize the magnitude of sales across years. The chart includes labeled axes and a title, with the time scale on the x-axis and a formatted sales scale on the y-axis. Built with D3 v5, the visualization uses `scaleTime`, `scaleLinear`, `line`, and `area` generators with `curveBasis`, along with `axisBottom` and `axisLeft` for tick rendering. Data is loaded from a CSV file and parsed with `d3.timeParse` before rendering as SVG elements.

Loading thumbnail…

Fork of Reusable D3 Scatter Plot

This example presents a reusable scatter plot visualizing the Iris Dataset, which cycles through different flower measurements as axes every two seconds. The plot uses D3 v6’s `scaleLinear`, `axisLeft`, `axisBottom`, and `selectAll` with a data join for animated SVG circles. The code defines a custom `scatterPlot` function with configurable accessors for x and y values, margins, and radius, driven by `setInterval` to update the plot’s dimensions.

Loading thumbnail…

Fork of ICE 7 Area Chart

This area chart visualizes the sales of cars in India from 2009 to 2019, using a smooth, curved line and a filled region beneath it to emphasize the trend. The visualization is created with D3 v5, parsing CSV data from a GitHub Gist. The code employs `select`, `scaleTime`, `scaleLinear`, and the `axisBottom` and `axisLeft` helpers to build the chart, while `area` and `line` generators, configured with `curveBasis`, define the filled area and the line path, respectively.

Loading thumbnail…

Fork of ICE 7 Area Chart

A combined line and area chart visualizes car sales in India from 2009 to 2019, with the area fill in orange and a black line tracing the trend over time. The chart uses D3 v5’s `scaleTime`, `scaleLinear`, `axisBottom`, `axisLeft`, and the `area` and `line` generators with `curveBasis` smoothing. Data is loaded via `csv` from a GitHub gist, parsed with `timeParse`, and rendered as SVG with styled axes and tick labels.

Loading thumbnail…

Fork of ICE 7 Reusable D3 Scatter Plot

This example presents an interactive scatter plot of the Iris dataset, where each flower species is represented by a distinct symbol from d3.symbol. The plot visualizes sepal length against petal width, with axes generated using d3.axisLeft and d3.axisBottom. A d3.scaleOrdinal maps species to symbol types, while d3.scaleLinear handles the x and y scales. Every 15 seconds, the x-axis dynamically switches between four numeric attributes—petal width, sepal width, petal length, and sepal length—using setInterval to re-render the chart with updated scales and positions.

Loading thumbnail…

Line Chart

This example uses a line chart to show the sales of a company over time, with years on the x-axis and sales values on the y-axis. The visualization includes labeled axes, a title, and a red line path. Built with React and D3 v5, it loads CSV data from a GitHub Gist and renders the chart as SVG. The code uses `d3.scaleTime`, `d3.scaleLinear`, `d3.axisBottom`, `d3.axisLeft`, and `d3.line` to map the data to visual elements.

Loading thumbnail…

Fork of Line Chart

This fork of a line chart displays company sales data over time, with companies on the x-axis and sales figures on the y-axis. The visualization uses a red line to connect data points, with axis labels and a title for context. It loads CSV data from a GitHub gist using d3.csv, parses the date and numeric values, and renders the chart as an SVG using d3.scaleTime, d3.scaleLinear, d3.axisBottom, d3.axisLeft, and d3.line.

Loading thumbnail…

Fork of Line Chart

This line chart visualizes US Auto Sales data from 2005 to 2022, plotting sales figures against company names. The chart uses a red stroke line to connect data points, with both axes labeled and gridlines rendered. The visualization is built using D3 v5's `scaleTime`, `scaleLinear`, `axisBottom`, `axisLeft`, and `line` APIs, with data loaded from a CSV via `d3.csv`. The SVG rendering includes styled tick marks, axis labels, and a title, with margins and dimensions defined in the code.

Loading thumbnail…

Fork of Fork of Line Chart

This line chart displays US Auto Sales from 2005 to 2022, showing sales values per company over time. The visualization uses d3.scaleTime and d3.scaleLinear to map the data, with d3.axisBottom and d3.axisLeft rendering the axes, and d3.line generating the path. Data is loaded via d3.csv from a GitHub gist and rendered as SVG elements. The chart includes labeled axes, a title, and a red line path styled through CSS.

Loading thumbnail…

Pie Chart

This example displays a pie chart of sales figures for different companies, with each segment labeled by its proportional value and paired with a legend showing company names and sales totals. The chart is rendered as SVG using D3 v5, with data fetched from a CSV URL. It uses D3’s `pie` and `arc` generators to create the segments, a `scaleOrdinal` to map sales values to a set of predefined colors, and custom text elements to label each slice.

Loading thumbnail…

Fork of ICE - 7 Pie Chart Manvitha reddy

This visualization displays the top 10 companies and their sales figures for 2020 using a pie chart. The chart segments are color-coded and labeled with sales values, and a legend on the right maps each company name to its corresponding color and sales amount. The code uses the D3.js library (d3.csv, d3.pie, d3.arc, d3.scaleOrdinal) to fetch data from a CSV file hosted on GitHub and render the SVG chart, with custom styling applied for text and legend elements.

Loading thumbnail…

Fork of Pie chart RDW

This D3.js (v6) example renders a simple pie chart using SVG, displaying four data points that map years (2013, 2014, 2015, 2019) to numeric values. The chart uses `d3.pie()` to compute arc segments and `d3.arc().outerRadius(200)` to define the pie geometry, with each slice filled by a category-10 color based on its value. Year labels are placed using the `centroid()` method of an inner arc, offset from the center. The data is hardcoded in the script, and the visualization is centered on a 400×400 SVG canvas using CSS transforms.

Loading thumbnail…

Iris Dataset Scatter Plot

This visualization uses D3.js v6 to render a scatter plot of the classic Iris dataset, mapping petal length on the x-axis and sepal length on the y-axis. Each circle represents a sample, colored by species (black for setosa, blue for versicolor, red for virginica). The code loads CSV data from a GitHub gist, uses `scaleLinear` and `extent` to compute scales, and renders SVG circles with axis labels, employing `axisLeft` and `axisBottom` for the chart axes.

Loading thumbnail…

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

This example shows the top 10 most populous companies ranked by 2020 sales using a horizontal bar chart. React manages component state while D3 functions such as `csv`, `scaleBand`, and `scaleLinear` handle data loading and scales. The visualization renders SVG rectangles with D3-style axes, including tick marks and labels. Data originates from a remote CSV file, and the React `useEffect` hook triggers the asynchronous data fetch.

Loading thumbnail…

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

This interactive bar chart displays the top 10 most populous countries using data loaded from a CSV file. The visualization uses React to render SVG marks, with D3’s `scaleBand` and `scaleLinear` mapping countries to horizontal bars and population values to their lengths. Grid lines, tick labels, and axis text are generated manually via D3 scales, while React’s `useEffect` and `useState` handle asynchronous data fetching and state management.

Loading thumbnail…

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

This interactive bar chart displays the top 10 most profitable countries from a sample sales record dataset. The visualization uses React with D3.js v5 to render SVG marks and channels, with the chart loading data from a GitHub-hosted CSV file. Rects encode profit values through their width along a linear scale, while country names are positioned on a band scale. The implementation leverages React's state management and useEffect for data fetching, alongside D3's scaleBand, scaleLinear, and csv parsing utilities.

Loading thumbnail…

ICE-6: Rendering Marks and channels with Rect & D3

This example visualizes the top 10 profit countries using a horizontal bar chart rendered as SVG in a React application. It displays country names on the y-axis and profit sales on the x-axis, with blue tick lines and axis labels. The code loads data from a CSV file using `d3.csv`, then uses `d3.scaleBand` and `d3.scaleLinear` to map values to `rect` marks. React manages the state and rendering, while D3 v7 handles data parsing and scales, with axes and bars drawn manually.

Loading thumbnail…

Fork of dataset

This example displays a horizontal bar chart of trading volumes for various Brazilian stock tickers, sourced from a local CSV file and rendered as SVG. The chart ranks the top 20 securities by volume, with bars extending from left to right and volume labels on the x-axis. The code uses D3.js imports such as `scaleLinear`, `scaleBand`, `axisBottom`, and `axisLeft` to construct the visualization, while data is loaded via the `csv` function. The rendering is handled through SVG elements within a 960x500 pixel canvas, with styling applied via CSS classes.

Loading thumbnail…

Fork of Visualization of data using React

This example shows a pie chart with one wedge per data row, colored by a hex value from the CSV and rendered as an SVG. It loads a sample sales record from a GitHub gist using `d3.csv`, then passes the parsed data to React state via `useState` and `useEffect`. The chart uses `d3.pie()` and `d3.arc()` with an outer radius equal to the SVG width, and maps each pie slice to a `<path>` element. The code also includes an unused `message` utility that reports list length 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 external CSV data using D3.js v7, displaying summary statistics about the dataset. The visualization fetches a remote CSV file via `d3.csv()`, which parses the data and returns a promise. The code then reports the file size in kilobytes, the number of rows, and the number of columns using `d3.csvFormat()`, presenting these metrics in a large, styled HTML `<pre>` element. The page uses basic CSS for visual emphasis, with a prominent heading and a light-cyan background for the output area.

Loading thumbnail…

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

This example demonstrates loading and parsing a CSV dataset with D3.js, displaying a summary message about the data. The page fetches a remote CSV file from a GitHub gist using the `d3.csv` function, then processes the parsed result to show the file size, row count, and column count in a large, styled `<pre>` element. The visualization uses D3 v7 within a plain HTML document, leveraging the `d3.csvFormat` API to calculate the data size. The message updates in place, providing immediate feedback about the dataset's structure.

Loading thumbnail…

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

This example demonstrates loading and parsing a CSV dataset with D3.js, displaying a summary message about the data. The page fetches a remote CSV file from a GitHub gist using the `d3.csv` function, then processes the parsed result to show the file size, row count, and column count in a large, styled `<pre>` element. The visualization uses D3 v7 within a plain HTML document, leveraging the `d3.csvFormat` API to calculate the data size. The message updates in place, providing immediate feedback about the dataset's structure.

Loading thumbnail…

ICE-5: Loading and parsing CSV Data with D3.js

This example demonstrates how to load and parse tabular data asynchronously using D3.js. It fetches a CSV file from a remote GitHub gist via the `d3.csv` API, then displays summary information about the parsed dataset in a styled HTML `<pre>` element. The code calculates the approximate file size using `d3.csvFormat` and reports the number of rows and columns. The page uses D3 v7 loaded from a CDN, with custom CSS styling for the heading and message area.

Loading thumbnail…

Fork of Let's make a face: part 3 tweaks

A stylized smiley face rendered on an SVG canvas, with a face circle filled by a horizontal linear gradient that transitions from white to black, and outlined by a contrasting gradient stroke. Two khaki circles form the eyes, positioned symmetrically above a khaki mouth shaped as a thick arc, generated using the D3 `arc` function with specified inner and outer radii and angular extents. The visualization is built with React, which constructs the SVG elements, while D3 provides the geometric path calculations for the mouth.