continuous.nice([count]) Extends the domain so that it starts and ends on nice round values. This method typically modifies the scale’s domain, and may only extend the bounds to the nearest round value. An optional tick count argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned ticks will exactly cover the domain. Nicing is useful if the domain is computed from data, say using extent, and may be irregular. For example, for a domain of [

continuous.invert(value) Given a value from the range, returns the corresponding value from the domain. Inversion is useful for interaction, say to determine the data value corresponding to the position of the mouse. For example, to invert a position encoding: var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); x.invert(80); // 20 x.invert(320); // 50 If the given value is outside the range, and clamping is not enabled, the mapping may be extrapolated such that the returne

continuous.interpolate(interpolate) If interpolate is specified, sets the scale’s range interpolator factory. This interpolator factory is used to create interpolators for each adjacent pair of values from the range; these interpolators then map a normalized domain parameter t in [0, 1] to the corresponding value in the range. If factory is not specified, returns the scale’s current interpolator factory, which defaults to interpolate. See d3-interpolate for more interpolators. For example, c

continuous.domain([domain]) If domain is specified, sets the scale’s domain to the specified array of numbers. The array must contain two or more elements. If the elements in the given array are not numbers, they will be coerced to numbers. If domain is not specified, returns a copy of the scale’s current domain. Although continuous scales typically have two values each in their domain and range, specifying more than two values produces a piecewise scale. For example, to create a diverging c

continuous.copy() Returns an exact copy of this scale. Changes to this scale will not affect the returned scale, and vice versa.

continuous.clamp(clamp) If clamp is specified, enables or disables clamping accordingly. If clamping is disabled and the scale is passed a value outside the domain, the scale may return a value outside the range through extrapolation. If clamping is enabled, the return value of the scale is always within the scale’s range. Clamping similarly applies to continuous.invert. For example: var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); x(-10); // -160, outside range x.inver

continuous(value) Given a value from the domain, returns the corresponding value from the range. If the given value is outside the domain, and clamping is not enabled, the mapping may be extrapolated such that the returned value is outside the range. For example, to apply a position encoding: var x = d3.scaleLinear() .domain([10, 130]) .range([0, 960]); x(20); // 80 x(50); // 320 Or to apply a color encoding: var color = d3.scaleLinear() .domain([10, 100]) .range(["brown", "

conic.parallels([parallels]) The two standard parallels that define the map layout in conic projections.

color.toString() Returns a string representing this color according to the CSS Object Model specification, such as rgb(247, 234, 186). If this color is not displayable, a suitable displayable color is returned instead. For example, RGB channel values greater than 255 are clamped to 255.

color.rgb() Returns the RGB equivalent of this color. For RGB colors, that’s this.