Skip to main content
SimilarExport ZIP
100%

Own testing

✓ Published0🌍 Public
Kkhuton
Last edited Feb 16, 2021
Created on Feb 16, 2021

This example visualizes two linear scales mapping x- and y-values from the data domain into screen coordinates, though no data points are rendered. Relying on D3 v6’s `scaleLinear` functions, it sets the y-domain from 0 to 200 and the x-domain from 0 to 50, each scaled to a 0–100 range on an SVG canvas. The chart’s structure is defined in static HTML and CSS, with a 960×500 SVG element, while the scaling logic is implemented in `index.js`. The visualization currently shows only the empty axes and scale setup, with no visible marks or data drawn.

AI-generated description
MIT Licensed

Similar vizzes

Loading thumbnail…

Scales and Axes

This example demonstrates how D3.js maps data values to screen coordinates using linear scales and renders labeled axes. A grey inner rectangle spans the plotting area, and the `scaleLinear` function transforms the domain 0–100 into pixel positions for both x and y dimensions. The `axisBottom` and `axisLeft` components generate tick marks and labels along the bottom and left edges, while the `join` method efficiently manages SVG elements. The visualization is created using D3 version 7.8.5, with the chart’s dimensions and margins dynamically calculated from the container size.

CCurran Kelleher
75% match
Loading thumbnail…

Fork of Scales and Axes

This example demonstrates D3 scales and axes by rendering a blank chart with a gray inner rectangle and labeled x and y axes. It uses `d3.scaleLinear` to map input data from 0 to 100 into pixel coordinates, with margins defining the plot area. The axes are created using `d3.axisBottom` and `d3.axisLeft`, which are appended to SVG groups and positioned via margin-based transforms. The code imports from the D3 v7 library and dynamically sizes the SVG to its container.

DDuc Pham
75% match
Loading thumbnail…

scale

This example demonstrates the foundational concept of D3 scales by computing and logging values from linear, square root, and time scales, then calculating the extent of a small dataset and applying a linear scale with a nice domain. It uses the d3 v7 library, importing scaleLinear, scaleSqrt, and scaleTime from d3, and renders to a blank SVG canvas. The code defines explicit domains and ranges to show how input values map to output pixel positions, with a dataset of five numeric values and an extent-based domain.

HHeet Bhatt
74% match
Loading thumbnail…

svg fund

This example demonstrates how a D3 linear scale maps an input value to an output range, using a simple numeric conversion from 0–100 to 0–500. The visualization outputs the mapped value for an input of 50, displaying 250 directly on the page. The code defines the scale with `d3.scaleLinear()`, setting its domain and range, then calls the scale function to compute the result. It relies on D3 v7 loaded from a CDN and renders the numeric output through `document.write` in the browser.

Jjaredaitken6
74% match
Loading thumbnail…

Scale & Axes

This example demonstrates the fundamental role of scales and axes in D3 data visualization. A gray plotting area is framed by a linear x-axis and y-axis, both spanning a domain from 0 to 100. The code uses `d3.scaleLinear` to map data values to screen coordinates, with `axisLeft` and `axisBottom` from D3 to render the ticks and labels. Margins are explicitly calculated to position the axes and the inner chart area, while the axes module manages the axis generation and text labels.

SSubhendu Karmakar
73% match
Loading thumbnail…

Fork of Scales and Axes

This example demonstrates how to construct a basic Cartesian coordinate system using D3 scales and axes. A dark grey inner rectangle is drawn within the SVG canvas to define the plotting area, while a linear scale maps the domain 0–100 to the horizontal and vertical pixel ranges. The bottom and left axes are rendered using `d3.axisBottom` and `d3.axisLeft` respectively. The `d3.scaleLinear` API handles the coordinate transformations, and the visualization responds to container resizing through a `ResizeObserver`.

Oownerofthesoul0000@gmail.com
72% match
Loading thumbnail…

D3: Drawing Scale

This example demonstrates how D3’s linear and square-root scales translate raw data coordinates into pixel positions and circle radii. It plots an array of 11 `[x, y]` pairs as circles and red text labels on an SVG canvas. The code uses `d3.scaleLinear()` for both the x and y axes, and `d3.scaleSqrt()` for sizing the circles proportionally. The scales are configured with custom domains and output ranges, with padding applied to keep marks inside the 500×300 viewport. Data is rendered statically, with labels showing the original coordinate values.

MMarisa Tania
72% match
Loading thumbnail…

D3 Scale Functions

This example demonstrates how D3 scale functions map input data values to visual output positions. It plots a set of numeric data points as circles along a horizontal axis, with each value labeled above its corresponding circle. The code uses `d3.scaleLinear()` to map the domain (0–10) to a pixel range, and renders the result as SVG elements. An axis is added using `d3.axisBottom()`, and the utility function `getScale` supports multiple scale types, including `scaleSqrt`, `scaleLog`, and `scaleBand`, though only linear is actively applied here.

SSubhendu Karmakar
72% match