Back to D3

d3-ease

docs/d3-ease.md

7.9.011.6 KB
Original Source
<script setup> import * as d3 from "d3"; import {ref} from "vue"; import ExampleEase from "./components/ExampleEase.vue"; const amplitude = ref(1); const exponent = ref(2); const period = ref(0.3); const overshoot = ref(1.7); </script>

d3-ease

Examples · Easing is a method of distorting time to control apparent motion in animation. It is most commonly used for slow-in, slow-out. By easing time, animated transitions are smoother and exhibit more plausible motion.

The easing types in this module implement the ease method which takes a normalized time t and returns the corresponding “eased” time . Both the normalized time and the eased time are typically in the range [0,1], where 0 represents the start of the animation and 1 represents the end; some easing types, such as easeElastic, may return eased times slightly outside this range. A good easing type should return 0 if t = 0 and 1 if t = 1.

These easing types are largely based on work by Robert Penner.

ease(t) {#_ease}

Given the specified normalized time t, typically in the range [0,1], returns the “eased” time , also typically in [0,1]. 0 represents the start of the animation and 1 represents the end. A good implementation returns 0 if t = 0 and 1 if t = 1. For example, to apply easeCubic easing:

js
const te = d3.easeCubic(t);

To apply custom elastic easing, create your easing function before the animation starts:

js
const ease = d3.easeElastic.period(0.4);

Then during the animation, apply the easing function:

js
const te = ease(t);

See also transition.ease.

easeLinear {#easeLinear}

<ExampleEase :eases='[{y: d3.easeLinear}]' />

Source · Linear easing; the identity function; linear(t) returns t.

easePoly {#easePoly}

Source · Alias for easePolyInOut.

easePolyIn {#easePolyIn}

<ExampleEase label="exponent" :eases='[0.5, 1, 1.5, 2, 3, 4].map((e) => ({y: d3.easePolyIn.exponent(e), stroke: e}))' />

Polynomial easing; raises t to the specified exponent. If the exponent is not specified, it defaults to 3, equivalent to easeCubicIn.

easePolyOut {#easePolyOut}

<ExampleEase label="exponent" :eases='[0.5, 1, 1.5, 2, 3, 4].map((e) => ({y: d3.easePolyOut.exponent(e), stroke: e}))' />

Reverse polynomial easing; equivalent to 1 - easePolyIn(1 - t). If the exponent is not specified, it defaults to 3, equivalent to easeCubicOut.

easePolyInOut {#easePolyInOut}

<ExampleEase label="exponent" :eases='[0.5, 1, 1.5, 2, 3, 4].map((e) => ({y: d3.easePolyInOut.exponent(e), stroke: e}))' />

Symmetric polynomial easing; scales easePolyIn for t in 0–0.5 and easePolyOut for t in 0.5–1. If the exponent is not specified, it defaults to 3, equivalent to easeCubic.

easePoly.exponent(e) {#easePoly_exponent}

<p> <label class="label-input"> <span>Exponent:</span> <input type="range" v-model.number="exponent" min="1" max="8" step="0.01"> <span style="font-variant-numeric: tabular-nums;">{{exponent.toFixed(2)}}</span> </label> </p> <ExampleEase label="exponent" :eases='[{y: d3.easePolyInOut.exponent(exponent)}]' />

Returns a new polynomial easing with the specified exponent e. For example, to create equivalents of easeLinear, easeQuad, and easeCubic:

js
const linear = d3.easePoly.exponent(1);
const quad = d3.easePoly.exponent(2);
const cubic = d3.easePoly.exponent(3);

easeQuad {#easeQuad}

Source · Alias for easeQuadInOut.

easeQuadIn {#easeQuadIn}

<ExampleEase label="exponent" :eases='[{y: d3.easeQuadIn}]' />

Quadratic easing; equivalent to easePolyIn.exponent(2).

easeQuadOut {#easeQuadOut}

<ExampleEase label="exponent" :eases='[{y: d3.easeQuadOut}]' />

Reverse quadratic easing; equivalent to 1 - easeQuadIn(1 - t). Also equivalent to easePolyOut.exponent(2).

easeQuadInOut {#easeQuadInOut}

<ExampleEase label="exponent" :eases='[{y: d3.easeQuadInOut}]' />

Symmetric quadratic easing; scales easeQuadIn for t in 0–0.5 and easeQuadOut for t in 0.5–1. Also equivalent to easePoly.exponent(2).

easeCubic {#easeCubic}

Source · Alias for easeCubicInOut.

easeCubicIn {#easeCubicIn}

<ExampleEase :eases='[{y: d3.easeCubicIn}]' />

Cubic easing; equivalent to easePolyIn.exponent(3).

easeCubicOut {#easeCubicOut}

<ExampleEase :eases='[{y: d3.easeCubicOut}]' />

Reverse cubic easing; equivalent to 1 - easeCubicIn(1 - t). Also equivalent to easePolyOut.exponent(3).

easeCubicInOut {#easeCubicInOut}

<ExampleEase :eases='[{y: d3.easeCubicInOut}]' />

Symmetric cubic easing; scales easeCubicIn for t in 0–0.5 and easeCubicOut for t in 0.5–1. Also equivalent to easePoly.exponent(3).

easeSin {#easeSin}

Source · Alias for easeSinInOut.

easeSinIn {#easeSinIn}

<ExampleEase :eases='[{y: d3.easeSinIn}]' />

Sinusoidal easing; returns sin(t).

easeSinOut {#easeSinOut}

<ExampleEase :eases='[{y: d3.easeSinOut}]' />

Reverse sinusoidal easing; equivalent to 1 - easeSinIn(1 - t).

easeSinInOut {#easeSinInOut}

<ExampleEase :eases='[{y: d3.easeSinInOut}]' />

Symmetric sinusoidal easing; scales easeSinIn for t in 0–0.5 and easeSinOut for t in 0.5–1.

easeExp {#easeExp}

Source · Alias for easeExpInOut.

easeExpIn {#easeExpIn}

<ExampleEase :eases='[{y: d3.easeExpIn}]' />

Exponential easing; raises 2 to the exponent 10 × (t - 1).

easeExpOut {#easeExpOut}

<ExampleEase :eases='[{y: d3.easeExpOut}]' />

Reverse exponential easing; equivalent to 1 - easeExpIn(1 - t).

easeExpInOut {#easeExpInOut}

<ExampleEase :eases='[{y: d3.easeExpInOut}]' />

Symmetric exponential easing; scales easeExpIn for t in 0–0.5 and easeExpOut for t in 0.5–1.

easeCircle {#easeCircle}

Source · Alias for easeCircleInOut.

easeCircleIn {#easeCircleIn}

<ExampleEase :eases='[{y: d3.easeCircleIn}]' />

Circular easing.

easeCircleOut {#easeCircleOut}

<ExampleEase :eases='[{y: d3.easeCircleOut}]' />

Reverse circular easing; equivalent to 1 - easeCircleIn(1 - t).

easeCircleInOut {#easeCircleInOut}

<ExampleEase :eases='[{y: d3.easeCircleInOut}]' />

Symmetric circular easing; scales easeCircleIn for t in 0–0.5 and easeCircleOut for t in 0.5–1.

easeElastic {#easeElastic}

Source · Alias for easeElasticOut.

easeElasticIn {#easeElasticIn}

<ExampleEase label="amplitude" :eases='[1, 1.1, 1.2, 1.3, 1.4, 1.5].map((a) => ({y: d3.easeElasticIn.amplitude(a), stroke: a}))' />

Elastic easing, like a rubber band. The amplitude and period of the oscillation are configurable; if not specified, they default to 1 and 0.3, respectively.

easeElasticOut {#easeElasticOut}

<ExampleEase label="amplitude" :eases='[1, 1.1, 1.2, 1.3, 1.4, 1.5].map((a) => ({y: d3.easeElasticOut.amplitude(a), stroke: a}))' />

Reverse elastic easing; equivalent to 1 - elasticIn(1 - t).

easeElasticInOut {#easeElasticInOut}

<ExampleEase label="amplitude" :eases='[1, 1.1, 1.2, 1.3, 1.4, 1.5].map((a) => ({y: d3.easeElasticInOut.amplitude(a), stroke: a}))' />

Symmetric elastic easing; scales elasticIn for t in 0–0.5 and elasticOut for t in 0.5–1.

easeElastic.amplitude(a) {#easeElastic_amplitude}

<p> <label class="label-input"> <span>Amplitude:</span> <input type="range" v-model.number="amplitude" min="1" max="4" step="0.01"> <span style="font-variant-numeric: tabular-nums;">{{amplitude.toFixed(2)}}</span> </label> </p> <ExampleEase label="amplitude" :eases='[{y: d3.easeElastic.amplitude(amplitude)}]' />

Returns a new elastic easing with the specified amplitude a. The amplitude a must be greater than or equal to 1.

easeElastic.period(p) {#easeElastic_period}

<p> <label class="label-input"> <span>Period:</span> <input type="range" v-model.number="period" min="0.1" max="1.5" step="0.01"> <span style="font-variant-numeric: tabular-nums;">{{period.toFixed(2)}}</span> </label> </p> <ExampleEase label="period" :eases='[{y: d3.easeElastic.period(period)}]' />

Returns a new elastic easing with the specified period p.

easeBack {#easeBack}

Source · Alias for easeBackInOut.

easeBackIn {#easeBackIn}

<ExampleEase label="overshoot" :eases='d3.ticks(0.5, 3, 6).map((a) => ({y: d3.easeBackIn.overshoot(a), stroke: a}))' />

Anticipatory easing like a dancer bending her knees before jumping off the floor. The degree of overshoot is configurable; if not specified, it defaults to 1.70158.

easeBackOut {#easeBackOut}

<ExampleEase label="overshoot" :eases='d3.ticks(0.5, 3, 6).map((a) => ({y: d3.easeBackOut.overshoot(a), stroke: a}))' />

Reverse anticipatory easing; equivalent to 1 - easeBackIn(1 - t).

easeBackInOut {#easeBackInOut}

<ExampleEase label="overshoot" :eases='d3.ticks(0.5, 3, 6).map((a) => ({y: d3.easeBackInOut.overshoot(a), stroke: a}))' />

Symmetric anticipatory easing; scales easeBackIn for t in 0–0.5 and easeBackOut for t in 0.5–1.

easeBack.overshoot(s) {#easeBack_overshoot}

<p> <label class="label-input"> <span>Overshoot:</span> <input type="range" v-model.number="overshoot" min="0" max="5" step="0.01"> <span style="font-variant-numeric: tabular-nums;">{{overshoot.toFixed(2)}}</span> </label> </p> <ExampleEase label="overshoot" :eases='[{y: d3.easeBack.overshoot(overshoot)}]' />

Returns a new back easing with the specified overshoot s.

easeBounce {#easeBounce}

Source · Alias for easeBounceOut.

easeBounceIn {#easeBounceIn}

<ExampleEase :eases='[{y: d3.easeBounceIn}]' />

Bounce easing, like a rubber ball.

easeBounceOut {#easeBounceOut}

<ExampleEase :eases='[{y: d3.easeBounceOut}]' />

Reverse bounce easing; equivalent to 1 - easeBounceIn(1 - t).

easeBounceInOut {#easeBounceInOut}

<ExampleEase :eases='[{y: d3.easeBounceInOut}]' />

Symmetric bounce easing; scales easeBounceIn for t in 0–0.5 and easeBounceOut for t in 0.5–1.