Galineeharika

Fork of ICE 8 - Country Map

This example displays a static choropleth-style map of countries, rendered as gray SVG paths with dark strokes on a white background. The code uses D3 v4’s `d3.geoPath` with a `d3.geoAlbersUsa` projection, though the title suggests a country map. It loads TopoJSON data from a remote gist via `d3.json`, then applies `topojson.feature` to extract country geometries. The map is positioned within an SVG using margin-based translation, styled with CSS from an external stylesheet.

Apr 13, 2023

Fork of Fork of ICE-8 Family Tree

This example shows a family tree rendered as an interactive hierarchical diagram, with nodes representing people and links showing parent-child relationships. Users can click on nodes to expand or collapse their children, while smooth transitions animate the tree’s layout changes. Built with D3.js v3, it uses `d3.layout.tree` to compute positions and `d3.svg.diagonal` for curved links, with SVG circles and text for nodes. The data is hardcoded as nested JavaScript objects, and the visualization responds to user interaction via click handlers.

Apr 13, 2023

Fork of Social Network Graph-ICE-8

This interactive social network graph displays the connections between nine individuals, with lines representing friendship links and circles representing people. The visualization uses a force-directed layout, where nodes arrange themselves based on simulated physical forces, and users can drag circles to reposition them. The code leverages D3.js version 6 APIs including `d3.forceSimulation`, `d3.forceLink`, and `d3.forceManyBody` to calculate the layout, while the data is loaded from a JSON file containing node IDs and link relationships. The SVG rendering includes hover effects that highlight nodes with a thicker stroke.

Fork of Fork of Fork of ICE8 - Social Network Graph

This interactive social network graph visualizes friendships among eight people (RAM, AMAR, HASH, NIKKI, ASHU, SREE, RAYZ, PINKY), with nodes representing individuals and directed links representing "Friend with" relationships. Built with d3.v6, it uses `d3.forceSimulation` with link, many-body, collision, and center forces to position the network. The SVG rendering includes circle nodes with labels, and users can drag nodes to rearrange the layout. The data comes from a JSON file defining the nodes and links.

ICE 8

This interactive family tree visualization displays a hierarchical dataset showing Marco, his children Martin and Jhon, and their descendants. Users can click any node to collapse or expand its subtree, with smooth 750-millisecond transitions animating the layout changes. The visualization uses the D3.js library, specifically the `d3.layout.tree` for computing the tree structure, `d3.svg.diagonal` for drawing curved links between nodes, and SVG elements with CSS styling for rendering. Node positions are normalized by depth, and circles indicate expandable nodes when filled with lightsteelblue.

Fork of MY Tree ICE-8

This interactive tree chart displays a family lineage, starting with Peddi Kumara and branching through multiple generations of children and grandchildren. Rendered as an animated SVG using the D3.js library (version 3.5.17) and its `d3.layout.tree` and `d3.svg.diagonal` APIs, the visualization lets users click on nodes to expand or collapse subtrees. The cyan and red circular nodes with blue connecting links are styled via CSS, and the tree is laid out vertically with a dark orange page background.

Fork of ICE8-Country map

This map of the United States displays all 50 states using an orange fill, with black state borders, and highlights individual states in green on hover. It renders geographic data from a TopoJSON us-atlas file using React and D3, applying the `geoAlbersUsaTerritories` projection and `d3.geoPath` to draw the land and interior boundaries. The visualization uses SVG for rendering and loads data asynchronously via a custom React hook with `useState` and `useEffect`.

Fork of ICE8 - USA Map

This example displays a choropleth-free map of the United States rendered as SVG, using a light gray sphere background with white landmasses and dark interior borders. It loads TopoJSON data from a GitHub gist, converting it to GeoJSON via `feature` and `mesh` from topojson. The visualization employs React for component structure and state management, while D3’s `geoAlbers` projection and `geoPath` generate the geographic paths. The code also defines a graticule but does not render it in the final output.

Fork of Bhanu Prasad ICE-8

This interactive tree diagram displays a hierarchy of car brands, grouping them under parent companies like Volkswagen, BMW Group, and Hyundai. Users can click nodes to expand or collapse branches, revealing or hiding child brands. The visualization uses the D3.js library, specifically the `d3.layout.tree` and `d3.svg.diagonal` APIs, to compute and draw the layout. It renders as an SVG with animated transitions (`duration = 750`), using circles for nodes and curved links for connections, with data hardcoded in a JavaScript array.

Fork of Fork of USA Country Map

A choropleth map of the United States shows each state as a filled, pink polygon with white interior boundaries, highlighting states on hover by turning them orange. Built with D3 v5, the visualization uses `geoAlbersUsaTerritories` for the projection and `geoPath` to render the geographic features. State boundaries come from the `us-atlas` TopoJSON file, processed via the TopoJSON library's `feature` and `mesh` functions, and displayed within a React application using SVG.

Fork of Fork of ICE8 - Country Map

This example renders a map of Australian electoral regions as colored SVG paths, with each region filled according to its electoral division using a categorical color scale. The code uses D3 v5’s `geoMercator` projection and `geoPath` to convert TopoJSON geometry into SVG paths, and labels each region with its name at the path centroid. The TopoJSON data is loaded from a local `australia.json` file, and the visualization is built within a React framework using the `topojson.feature` API to extract region shapes.

Fork of Fork of Nikita's USA Country Map

This visualization displays a choropleth map of the 50 U.S. states, with each state filled in blue and state boundaries drawn as black interior lines. The map uses a geo-albers-usa-territories projection via `geoAlbersUsaTerritories()` and renders geographic shapes with `d3.geoPath()`. Data is loaded from the `us-atlas` TopoJSON file and processed using the `feature()` and `mesh()` functions from TopoJSON. The React-based implementation uses hooks (`useState`, `useEffect`) to manage data fetching, and SVG paths are generated for each state feature. Hovering over any state highlights it in purple through CSS.

Fork of ICE-8(11630234)

This interactive map of India displays state and district boundaries, visualized with SVG paths and colored by state using `d3.scaleOrdinal` and `schemeCategory10`. It supports zooming and panning through `d3.zoom`, and uses `d3.geoMercator` with a centered projection on India. The map loads TopoJSON data from external GitHub sources, including India states and districts, and renders tooltips with district and state names. Hovering over districts changes their fill to black via a CSS transition.

Fork of Fork of USA Country Map

Fork of Fork of USA Country Map

Fork of Fork of ICE - 8: Family Tree

This example shows an interactive family tree starting with Prem Kohli and branching down through Saroj, Vikas, and Virat Kohli, rendered as a hierarchical node-link diagram. Clicking a node with children collapses or expands its subtree, with smooth 750ms transitions animating the nodes into place. The visualization uses D3’s `d3.layout.tree`, `d3.svg.diagonal` for curved links, and SVG transitions, with styling defined in a `<style>` block for node circles and link strokes in pink. The tree data is hardcoded in a JavaScript array.

Fork of Fork of ICE 8 - Country Map

This example displays a map of the United States rendered as grey SVG paths with dark strokes. The visualization uses D3 v4’s `d3.geoPath` and the `d3.geoAlbersUsa` projection to draw country boundaries from TopoJSON data loaded via `d3.json` and parsed with `topojson.feature`. The map is centered within an SVG container using a fixed translate transform, with styling applied through CSS and inline attributes.

Fork of ICE 8 - Country Map

This example displays a static map of the United States with all states filled in red, rendered as SVG paths on a light green background. The map is generated using D3.js version 4, employing the `d3.geoPath` projection with the `d3.geoAlbersUsa()` projection function to properly center the contiguous states and Alaska. It loads GeoJSON state boundaries from the us-atlas dataset via `d3.json` and processes them with the topojson-client library to extract the state features. The visualization is a simple, non-interactive choropleth without additional data encodings.

Fork of ICE 8 - Country Map

This example renders a choropleth-style map of the United States, showing state boundaries as green polygons on a light blue background. It uses d3.geoPath with a d3.geoAlbersUsa projection to draw the map, and topojson-client’s topojson.feature to extract state geometries from the us-atlas states-10m dataset. The SVG output is positioned with margins and styled entirely via embedded D3 attributes, with no interactive or hover behavior.

Fork of Fork of India Map: ICE-8

This example visualizes a map of India with each state filled using a categorical color scale. It renders every state as an SVG path and labels each one with its name centered on the state's centroid. The code uses D3 v5 APIs including `geoMercator`, `geoPath`, `scaleOrdinal`, and `schemeCategory10`, along with TopoJSON's `feature` method. State boundary data comes from a remote GeoJSON file hosted on GitHub, and the map is drawn with thick black strokes between states.

Fork of Fork of ICE8 - USA Map

This example displays a choropleth-style map of the United States, rendering landmasses as white filled polygons and state boundaries as colored lines over a light teal sphere. It uses D3’s `geoAlbers` projection, `geoPath`, and `geoGraticule` to generate SVG paths from TopoJSON data loaded from a GitHub gist. The React component `CountryMap` renders the sphere, land features via `feature`, and state interiors via `mesh`, with styling defined in external CSS. Data loading occurs asynchronously using D3’s `json` function within a React hook.

Fork of Fork of Fork of World Map IC8

This example shows a natural Earth projection of the world map, with countries rendered as black filled paths with subtle maroon strokes over a grey sphere. The visualization uses D3’s `geoNaturalEarth1` projection and `geoPath` to generate SVG paths from TopoJSON data fetched from a GitHub gist. It relies on the `topojson` library’s `feature` method to extract country geometries, then appends them to an SVG canvas. The code demonstrates a minimal React-free setup, with the map loaded asynchronously via `json`.

Fork of World Map

This orthographic world map displays Earth's landmasses and country borders using a sphere projection with graticules. The visualization renders SVG paths via d3.geoPath and d3.geoOrthographic, styling land in teal, interiors as light strokes, and the sphere in gray. Data is loaded from the world-atlas TopoJSON file with topojson.feature and topojson.mesh within a React component. The example uses d3.v7 and React 17, presenting a static globe without interaction or animation.

Fork of world map w/ cities & countries pop!

A global map visualizes cities and countries by population using a natural Earth projection. City markers sized with a square-root scale encode population, while country fill opacity encodes population data, with a distinct class for missing values. The visualization uses `d3.geoPath`, `d3.geoNaturalEarth1`, and `d3.geoGraticule` for map rendering, with data loading via `d3.csv` and `d3.json`, and React for the interface.

Fork of Fork of ice8-vignesh

A world map rendered with SVG paths shows countries in blue on a graticule; clicking a country switches the map between orthographic and Mercator projections, and the map can be rotated by dragging. Built with D3.js, it uses `d3.geoPath`, `d3.geoOrthographic`, `d3.geoMercator`, and `d3.geoAlbersUsa` for projections, and `d3.drag` and `d3.zoom` for interaction. Country boundaries come from the `world-atlas` TopoJSON dataset, while country names are loaded from a TSV file.