B

Burak Senel

@gecersiznick·17 public vizzes

Loading thumbnail…

scatterplot

This scatterplot displays the population of various countries using a horizontal bar chart layout, with each bar’s length proportional to the population value from the UN Population 2019 CSV dataset. The visualization is built with React and D3 v6, using `scaleBand` for the categorical y-axis and `scaleLinear` for the x-axis. SVG shapes are rendered through React components, with axes and marks created using `AxisBottom`, `AxisLeft`, and `Marks` components. Tooltips are implemented via native SVG `<title>` elements, and tick formatting uses D3’s `format` function to convert values to billions.

Loading thumbnail…

Stylized bar chart

This stylized bar chart displays the populations of the top 10 countries from the UN Population 2019 dataset. It uses React with D3 v6’s `scaleBand` and `scaleLinear` to map countries and population values, rendering bars as SVG rectangles with tooltips via the `<title>` element. The chart includes formatted axis ticks using `d3.format` and a Poppins font, with axes built from custom React components.

Loading thumbnail…

refactored bar chart

This example shows a horizontal bar chart of population estimates for the top 10 countries in the UN Population 2019 dataset, with the country names on the y-axis and the population values on the x-axis. The SVG visualization is built with React components that use d3.scaleBand and d3.scaleLinear to map the data, while the axes and bars are rendered as reusable components. Data is loaded asynchronously with d3.csv and parsed to convert the population values from strings to numbers.

Loading thumbnail…

axes with react d3

This example displays a horizontal bar chart of the top 10 countries by 2020 population, using React to render SVG elements and D3.js for data processing and scales. It fetches UN population data from a CSV file via `d3.csv`, then applies `scaleBand` for the y-axis and `scaleLinear` for the x-axis to position bars and grid lines. Axis ticks are generated with `xScale.ticks()` and placed using SVG `<line>` and `<text>` elements, while country labels appear on the left. The chart updates asynchronously, showing a loading message until the data arrives.

Loading thumbnail…

Margin convention

This example demonstrates the margin convention in D3 by rendering a horizontal bar chart of UN population data for ten countries. The SVG output positions a grouped `<g>` element with margins applied via a `transform` attribute, while `scaleBand` and `scaleLinear` map country names and population values to the inner chart dimensions. The React component manages asynchronous CSV loading with `useState` and `useEffect`, and the code explicitly imports `csv`, `scaleBand`, `scaleLinear`, and `max` from the D3 v6 bundle.

Loading thumbnail…

UN population countries

A bar chart displays the top 10 most populous countries in 2020 using UN population data, with horizontal bars sized by `Population` values. The React app loads CSV data via `d3.csv`, filters the first ten rows, and renders SVG `<rect>` elements using `d3.scaleBand` for the y-axis country categories and `d3.scaleLinear` for the x-axis population scale. The chart updates after an asynchronous data fetch, showing a loading state before the visualization appears.

Loading thumbnail…

Fork of Rendering data with React

This example visualizes the CSS named colors as a pie chart, with each slice filled by the corresponding color’s RGB hex value. The visualization loads CSV data from a GitHub gist using `d3.csv`, then computes the pie layout with `d3.pie` and renders the arcs using `d3.arc`. Built with React, the component uses `useState` and `useEffect` to asynchronously fetch and store the data, displaying a “Loading...” message until the data arrives. The chart is drawn as an SVG, with each path element generated from the pie data.

Loading thumbnail…

Rendering data with React

This example displays the CSS named colors as a vertical stack of horizontal strips, each rendered as a div with the color’s hex value as its background. The data loads asynchronously from a CSV file via d3.csv, and React’s useState and useEffect manage the loading state and trigger the fetch. Once parsed, the data maps to a list of divs, with each div’s height fixed at 4 pixels and width at 960 pixels. The visualization uses React to render SVG-independent HTML elements, with d3.v6 handling the CSV parsing, and React 16.9 managing the component lifecycle and dynamic rendering.

Loading thumbnail…

Loading and Parsing CSV Data

This example demonstrates how to load external CSV data in a web browser and parse it into a JavaScript object using D3.js version 6. The code fetches a remote CSV file containing CSS named colors, then applies `d3.csvParse` to convert the raw text into structured rows and columns. It logs the number of rows, columns, and file size to the console, showcasing the basic workflow of asynchronous data retrieval with the native Fetch API combined with D3's parsing utilities.

Loading thumbnail…

Mouse follower

A circle follows the mouse cursor across a full-screen SVG canvas, with its position updating in real time to match the pointer’s coordinates. The visualization uses React’s `useState` hook to store the cursor’s `clientX` and `clientY` values, triggered by an `onMouseMove` event on the SVG element. The circle is rendered as an SVG `<circle>` with a fixed radius, demonstrating a simple interactive state-driven rendering approach.

Loading thumbnail…

Fork of Smiley Face Part IV

This fork of a Smiley Face visualization uses React and D3 to render a stylized face with configurable components. The image shows a yellow circle with black outline, two eyes, and a D3 arc-based mouth, all positioned within an SVG canvas. The code defines reusable React components—BackgroundCircle, Eyes, Mouth, and FaceContainer—that parameterize dimensions and positions. D3's arc API generates the mouth’s curved path, while React manages the SVG element hierarchy and rendering.

Loading thumbnail…

Fork of Smiley Face Part V

A smiling face is rendered as an SVG across modular React components, with a yellow background circle, two eyes, and an arc-based mouth. The code splits the face into separate ES6 modules for the background, eyes, and mouth, using React Fragments and the `arc()` generator from D3 v5 to define the mouth’s curved path. Everything is centered within an SVG canvas using a translated `<g>` group, with dimensions and offsets passed as props from the main app component.

Loading thumbnail…

Fork of Smiley Face Part III

This example shows a smiling face built with React and D3, rendered as SVG shapes. The code combines React’s component model with D3’s `arc` generator to draw the mouth as a path, while circles define the face, eyes, and stroke. It uses fixed numeric constants for dimensions and positioning, and renders the entire composition inside a single SVG element. The example demonstrates an idiomatic hybrid approach where D3 handles geometry generation and React manages the DOM updates.

Loading thumbnail…

Fork of Smiley Face Part III

A yellow smiley face with black strokes is rendered as an SVG centered on a 960-by-500 canvas. It uses React components and D3.js to define circles for the head and eyes, and d3’s `arc` generator to create the mouth path. The code computes positions from constants and draws the face with a yellow fill, black stroke, and specified stroke width.

Loading thumbnail…

Fork of Smiley Face Part II

A full-window smiley face is drawn with D3 arcs and React, using a yellow circle for the head, two dark eye circles, and a mouth arc that follows a half-circle path. The visualization adapts to the browser’s viewport size, centering the face and calculating the head radius from the window height. The code uses React for rendering the SVG elements, D3’s `arc()` API to generate the mouth path, and responds to window dimensions via `window.innerWidth` and `window.innerHeight`.

Loading thumbnail…

Fork of Let's Make a Face Part I

A yellow smiley face rendered as SVG, with a black circular face and two black eyes positioned symmetrically on either side of the center. The code defines constants for dimensions, offsets, and radii, then uses React to create three circle elements. It leverages ReactDOM to mount the component, with SVG attributes set via JSX, and the rendering relies on the React production build loaded from a CDN.

Loading thumbnail…

Smiley face part I

A static SVG smiley face spans the full canvas: a yellow circle with a black outline, two solid black circles for eyes, and no mouth. The page loads directly into a 960×500 viewport with hidden overflow. The drawing relies solely on basic SVG `<circle>` elements, with coordinates and radii set via `cx`, `cy`, `r`, plus `fill` and `stroke` attributes. No external libraries or data sources are involved; the image is hand-coded in the HTML.