Jenna Hamza

Fork of Stylized Line Chart

This fork of a stylized line chart visualizes temperature over time for a week in San Francisco, sourced from the Data Canvas Sense Your City dataset. The SVG chart, rendered with React and D3 v5, displays a smooth, natural curve using `line()` and `curveNatural` from d3, with custom axes via `AxisBottom` and `AxisLeft`. The Poppins font and teal color scheme style the visualization, while the data is loaded asynchronously via `csv()` from a GitHub gist.

Jan 9, 2023

Menus w/ React

This example demonstrates a basic React dropdown menu for selecting a pet, with the current choice stored in state and displayed via a large label and select element. The code uses React's `useState` hook to manage the selected value and a reusable `Dropdown` component that renders a native HTML `<select>` element. The dropdown is populated with a static array of pet options and updates the displayed selection live when the user changes it. The interface is styled with oversized text via inline CSS in the HTML template.

Jan 6, 2023

React Starter

This example shows a minimal React application that renders the text “Hello React” on a blank page. It uses React and ReactDOM to create and mount a functional component into a root div, with the page styled to have no margin and hidden overflow. The code imports React and ReactDOM, defines an App component that returns a simple div, and calls `ReactDOM.render` to display it in the browser.

Jan 5, 2023

World Map

This world map visualization displays countries and landmasses using an equal-area Natural Earth projection. The SVG rendering layers a graticule, sphere outline, land polygons, and interior boundaries in muted teal and gray tones. Built with React and D3 v7, it fetches world-atlas TopoJSON data, converts it with topojson’s `feature` and `mesh` functions, and projects geometries via `geoNaturalEarth1` and `geoPath`. The map highlights relationships between countries by drawing interior boundaries where adjacent nations meet.

Jan 5, 2023

Iris Data ScatterPlot

This scatterplot visualizes the classic Iris dataset by plotting sepal length on the x-axis against sepal width on the y-axis. It uses React with d3.v7's `csv` loader to fetch and parse the data, `scaleLinear` and `extent` for continuous scaling, and renders SVG circles via a `Marks` component. Custom `AxisBottom` and `AxisLeft` components generate tick marks and labels, while CSS styles define the plot's color scheme and typography.

Stylized Bar Chart

A stylized bar chart displays population estimates for ten countries, with horizontal bars ranked by country name and labeled with formatted population values. The visualization uses React to manage component state and render SVG elements, while D3 v7 provides scales for positioning and axes. Data loads from a CSV file of UN population figures for 2020. The chart applies custom styling with Poppins typography, teal-colored marks, and formatted tick labels that abbreviate large numbers using D3's SI format.

Refactored Bar Chart

This example shows a horizontal bar chart of population data for the top ten countries, with a linear scale for population and a band scale for country names. It is built with React, D3 v7, and SVG, using custom components for the axes and bars. The data is loaded from a CSV file via D3's `csv` function, and the chart is rendered declaratively by mapping the dataset to SVG `rect` and `text` elements.

Axes with React & D3

This example shows a bar chart of the top 10 countries by 2020 population, fetched from a CSV file. React manages the loading and state of the data, while D3 computes scales and renders the axes and rectangles as SVG elements. The implementation uses `d3.csv`, `d3.scaleBand`, and `d3.scaleLinear` for data parsing and axis mapping, with React’s `useState` and `useEffect` hooks orchestrating the asynchronous data fetch.

The Margin Convention

This example visualizes the first ten countries from the UN Population 2019 dataset as a horizontal bar chart, showing each country’s population. The chart is rendered as an SVG within a React component, with the data loaded via `d3.csv`. The visualization uses `d3.scaleBand` for the categorical y-axis and `d3.scaleLinear` for the population x-axis, while the layout respects a fixed margin convention with 20-pixel insets on all sides. A status message first displays the dataset’s row and column counts before the bars appear.

pathetic bar chart

This example visualizes the population data of the ten most populous countries as horizontal bars, initially fetched from a CSV file using `d3.csv`. The visualization uses D3’s `scaleBand` and `scaleLinear` to map country names to y-positions and population values to bar widths. React manages the state of the loaded data, while SVG rectangles are rendered with ReactDOM. The bars display country names along the vertical axis, with bar lengths proportional to their 2020 population figures, providing a straightforward comparison of population sizes across those nations.

Loading Data with React & D3

A radial burst of colored arcs represents all CSS named colors, with each slice filled by its corresponding RGB hex value and sized equally to form a full circle. The example demonstrates asynchronous data loading in React: a `useEffect` hook triggers d3.csv to fetch the dataset from a GitHub gist, storing the parsed rows in component state. Once loaded, d3.pie and d3.arc compute the slice geometry, while React renders each SVG path. Before data arrives, a loading message displays the row count, column count, and file size in kilobytes using d3.csvFormat.

Fork of Vega-Lite API Template

This example visualizes the relationship between vehicle weight, horsepower, and fuel efficiency using data from an auto-mpg dataset loaded via D3’s `csv` function. It renders a scatterplot where each point’s position encodes mpg and horsepower, color encodes origin, and size encodes weight, with tooltips showing car names. The visualization is built declaratively with the Vega-Lite API (`vl.markPoint`, `vl.encode`), registered with Vega and Vega-Lite, and rendered in SVG with a customized dark theme and axis styling.

CSS Data Viz exercise

This example demonstrates the basic usage of D3 to load and summarize a CSV dataset. It fetches a CSV file containing CSS named colors from a GitHub gist using `d3.csv`, then displays the dataset’s row count, column count, and approximate file size in kilobytes. The computed information is rendered as plain text inside a `<pre>` element with a large font size. The code relies on D3’s CSV parsing and formatting utilities, including `d3.csv`, `d3.csvFormat`, and the resulting data array’s `length` and `columns` properties.

Dec 29, 2022

Circle Follower

A circle follows the mouse cursor across an SVG canvas, updating its position in real time as the pointer moves. Built with React and d3.v7, the app uses React’s `useState` and `useCallback` hooks to track and update the mouse coordinates on every `onMouseMove` event, rendering a single `<circle>` element with a radius of 30 pixels. The example relies on SVG rendering within a 960×500 viewport, with the initial circle centered at the midpoint of the canvas.

Dec 29, 2022