gharakhani1986

Fork of Let's make a map with D3.js!

This example shows an interactive world map built with D3.js v5 and TopoJSON, displaying country boundaries with hover effects that highlight each nation in red. The map uses a natural Earth projection via `d3.geoNaturalEarth1` and renders geographic features as SVG paths with `d3.geoPath`. Pan and zoom interactions are enabled through D3’s `zoom` behavior, transforming the map group on user input. Country names are loaded from a TSV file and matched to geographic IDs, with tooltips shown via SVG `<title>` elements. The code also leverages `d3-geo-projection` and world-atlas data.

Fork of Fork of Bowl of Fruit - Hover to Select

Using D3 v5, this visualization displays a row of five apples as colored circles that animate in size and position. Hovering over any fruit highlights it with a black stroke and clears the selection on mouseout. The code uses `scaleOrdinal` for color and radius, `transition().duration()`, and a data join with `enter`, `merge`, and `exit`. Over time, `setTimeout` calls remove apples or change one to a lemon, demonstrating animated updates to the SVG scene.

Fork of Bowl of Fruit - Click to Select

A circle represents each fruit, with apples and lemons distinguished by color and size, and clicking a fruit selects it by adding a black stroke. The visualization uses D3 v5 with a data join to update SVG circles across timed changes that remove fruits, replace an apple with a lemon, and filter the array. Transition methods animate radius and x-position changes, while ordinal scales map fruit type to color and radius.

Fork of Bowl of Fruit - Click to Select

A circular SVG chart displays five apples as red circles with black outlines, allowing a viewer to click any apple to select it, which highlights the chosen fruit with a thicker stroke. D3's `scaleOrdinal` maps fruit types to fill colors and radii, while React's `useState` manages both the fruit collection and the selected identifier. The visualization is built with React components rendering SVG circles, using D3 v5 for scales and React 16.8 for stateful interaction logic.

Fork of Bowl of Fruit - General Update Pattern

This example demonstrates the D3 general update pattern for data joins, showing a bowl of fruit that changes over time as apples are eaten or replaced with lemons. The visualization uses D3 v5 with SVG rendering, where circles and text labels are bound to an array of fruit objects. The code explicitly handles enter, update, and exit selections through `selection.merge()` and `selection.exit().remove()`, while `scaleOrdinal` maps fruit types to colors and radii. A series of `setTimeout` callbacks triggers state changes, animating the transitions between the three fruit configurations.

Jul 17, 2022

Fork of Bowl of Fruit - General Update Pattern Special Cases

This example demonstrates the general update pattern in D3.js, showing how the enter, update, and exit selections handle fruit bowl data changes. It uses D3 v5 with SVG rendering to draw circles and text elements. The code explicitly manages data joins with `selection.enter()`, `selection.merge()`, and `selection.exit()`, while `scaleOrdinal` maps fruit types to colors and radii. Timeline-driven actions add, remove, and modify fruits, revealing how the update pattern handles special cases such as keyless data binding and in-place data changes.

Jul 17, 2022

Fork of Bowl of Fruit - General Update Pattern Special Cases

A dynamic SVG animation demonstrates the general update pattern for data joins, showing how enter, update, and exit selections handle changing fruit data. Five apples initially render as red circles, then sequentially: one apple is removed, one becomes a lemon, and another is filtered out. The code uses `d3.selectAll('circle').data(fruits)` with `.enter()`, `.merge()`, and `.exit()` methods, applying `transition().duration(1000)` for smooth radius changes. Fruit types map to colors and sizes via `scaleOrdinal`, with circles transitioning between states before removal.

Jul 16, 2022

Fork of Bowl of Fruit - General Update Pattern Special Cases

Five apples animate into a row, then the sequence removes one, changes one to a lemon, and deletes another, demonstrating the D3 general update pattern’s special cases. The code uses `selection.data`, `enter`, `merge`, and `exit` with `transition.duration`, scaling circle colors by fruit type via `scaleOrdinal`. Rendering is SVG with D3 v5, driven by timed `setTimeout` calls.

Jul 13, 2022

World Population Area Chart

This world population area chart displays the growth of global population over time, using a smooth, maroon-filled area curve. The visualization leverages D3.js v7 functions including `scaleTime`, `scaleLinear`, `area`, `curveBasis`, `axisBottom`, and `axisLeft` within an SVG canvas. The code loads CSV data from a VizHub URL, parses years as dates and populations as numbers, and renders a titled chart with gridlines, axis labels, and formatted tick marks that convert billions (G) to B.

Fork of Fork of Temperature in San Francisco Area Chart

This area chart visualizes a week of temperature readings in San Francisco, with time on the x-axis and temperature on the y-axis. The chart uses a maroon filled area beneath a curved line to emphasize the temperature trend across the week. Built with D3 v7, it employs `d3.scaleTime`, `d3.scaleLinear`, `d3.area`, and `d3.curveBasis` to generate the smooth path, while `d3.axisBottom` and `d3.axisLeft` render the labeled axes. Data is loaded as CSV from an external URL.

Fork of Temperature in San Francisco

This example visualizes a week of temperature readings in San Francisco using an area chart that fills the space between a curve and the baseline. The chart includes labeled axes for time and temperature, with gridlines and a title. The code uses D3 v7’s `csv` loader to fetch the dataset, `scaleTime` and `scaleLinear` for scales, `axisBottom` and `axisLeft` for axes, and the `area` generator with `curveBasis` to create the smooth filled path rendered as SVG.

Fork of Temperature in San Francisco

A line chart visualizes a week of temperature changes in San Francisco, using a smooth basis curve to connect data points over time. The D3.js code loads CSV data from a remote source, parses timestamps and numeric temperature values, and renders an SVG graphic with labeled time and temperature axes. It employs `select`, `csv`, `scaleTime`, `scaleLinear`, `axisLeft`, `axisBottom`, and `line` with `curveBasis` to build the visualization, adding gridlines via tick marks and removing axis domains for a clean look.

Fork of Scatter Plot

This example displays a scatter plot of country reserves, with each circle’s horizontal position mapped to the reserve value and vertical position to the country name using a point scale. The visualization uses D3.js (v7) to load CSV data, build linear and point scales, and render axes with tick formatting. Grid lines are created by negative tick sizes, and axis labels are added manually, with circles styled via CSS.

Shapes with SVG and CSS

This example displays a simple SVG scene composed of a green circle and a black-outlined rectangle, both grouped within an SVG element. The shapes are positioned using the `transform` attribute and styled with inline fill and stroke properties, while a linked stylesheet defines global body margins and a `.highlighted` class. The visualization demonstrates foundational SVG shape rendering and CSS integration in a static, non-interactive HTML document.

Fork of Cars Report

This example demonstrates a simple report generator that filters a small dataset of used cars by price and displays the results as formatted text. It loads car data asynchronously from a JSON string using a JavaScript Promise, then applies array methods like `filter` and `map` to select and format entries. The code uses ES6 modules, including `import` and `export` statements, with functions such as `getCars`, `generateReport`, and `formatCar` to handle data processing. The output renders in the browser as a plain-text list of matching cars under a $2000 threshold.

HTML Cars Report

This example presents an interactive HTML-based report that visualizes automobile data as a dynamic, animated display. The page uses SVG for rendering and employs the D3.js library for force simulations and data binding, with a YouTube video embedded for additional context. The visualization’s layout and movement are driven by `d3.forceSimulation`, while SVG elements are manipulated through standard D3 selections and transitions. The report is contained in a single HTML file, with the chart’s structure and styling defined inline, and the video starting at a specific timestamp to highlight relevant features.

Fork of Cars Report

This fork demonstrates a simple JavaScript report generator using ES6 modules and asynchronous data loading. It parses an embedded JSON array of five cars, filters them by a price threshold, and formats each result as a string with year, make, model, and price. The `getCars()` function returns a Promise that resolves after a two-second delay, simulating an API call. The final report replaces a “Loading...” message in the page’s `<pre>` element, showcasing object destructuring and array methods like `filter` and `map`. The example also includes a separate test file that accesses car data directly.