Geometry
The type of the chart is determined by geometry.
chart.<geomType>()
.position()
.size()
.color()
.shape()
.adjust()
.style()
.animate();
The following is a simple grammar for a basic bar chart..
chart.interval().position('x*y').color('x');
NOTE: The return of the above method chart.interval()
is a geom instance, not a chart instance.
Currently we support 7 geometry types:
Type
Description
point
point, used for drawing point chart, scatter chart, bubble chart.
path
path, a line of unordered connected.
line
line, used for drawing line chart, and the data will be ordered.
area
area, used for drawing area chart
interval
used to form a bar chart or a pie chart.
polygon
It is usually used to form heat map chart or map.
schema
Used to form a candlesticks chart or box chart.
Properties
chart.<geomType>({
generatePoints: {Boolean},
sortable: {Boolean},
startOnZero: {Boolean},
connectNulls: {Boolean}
})
generatePoints
generatePoints
type:
Boolean
description: Wether to generate multiple points to draw charts, if true, multiple points will be generated.
default: false for line and path, other geometry types default to be true.
chart.line({
generatePoints: true
})
sortable
sortable
type:
Boolean
description: Whether to sort the data according to the corresponding field of the x-axis, and sort it when true
default:
true
for area and line, other geometry types default to be false.
Note: When drawing a line or area chart, if your data has been sorted, you can set this property to false
to improve performance.
chart.line({
sortable: false
})
startOnZero
startOnZero
type:
Boolean
description: Wether to set the baseline of the y-axis starting from 0, default to be true, means starts from 0.
default: true
chart.line({
startOnZero: false
})
The usage scenarios for this property are as follows:
connectNulls
type:
Boolean
description: Used to set whether to connect empty data (for line, area and path types)
default: false
chart.line({
connectNulls: true // connect empty data
});
Methods
position()
position()
Declare the two data fields which determine the position of data points. Choose one of the following two ways to declare:
chart.line().position('x*y');
chart.line().position([ 'x', 'y' ]);
The following code will render a bar chart, which the x-axis representing the fruit
and the y-axis representing the price
.
const data = [
{ fruit: 'apple', price: 2 },
{ fruit: 'orange', price: 1.5 },
{ fruit: 'banana', price: 0.8 }
];
const chart = new F2.Chart({
id: 'mountNode',
pixelRatio: window.devicePixelRatio
});
chart.source(data);
chart.interval().position('fruit*price');
chart.render();

color()
color()
A method of mapping data values ​​to the color of the geometry.
chart.line().color('red'); // Color
chart.line().color('fieldName'); // use the built-in colors to map field
chart.line().color('fieldName', [ 'red', 'blue' ]) // specify colors
chart.line().color('fieldName', (type) => { // use callback to map data to colors
if (type === 'a') {
return 'red';
}
return 'blue';
});
chart.line().color('fieldName*value', (type, value) => { // multiple parameters, use callback to map
if (type === 'a' && value > 100) {
return 'red';
}
return 'blue';
});
color(value)
value
: String
At this time, value can be:
The data field mapped to the color attribute. If the field name does not exist in the data, it will be parsed as a constant. This time, the default color provided by F2 will be used.
also can be a specific color value, such as 'red', '#ddd', '#dddddd', 'rgb(255, 10, 30)' or
'l(0) 0:#ffffff 0.5:#7ec2f3 1:#1890ff'
.
chart.point().position('x*y').color('x'); // use the built-in color to map the data field of x-axis
chart.point().position('x*y').color('red'); // all points are mapped to red
chart.area().position('x*y').color('l(0) 0:#ffffff 0.5:#7ec2f3 1:#1890ff'); // fill a gradient
color(fieldName, colors)
fieldName
: StringData field name mapped to colors, multiple fields are supported.
colors
: String / Array / FunctionIf colors is null, the built-in colors are used;
If you need to specify colors, you need to pass in an color array.
chart.point().position('x*y').color('z'); // use default colors chart.point().position('x*y').color('z', [ 'red', 'blue' ]); // specify colors
When the map field is a linear scale type(for continuous quantitative data), you can declare the gradient color as follows, detailed demo here.
chart.polygon().position('name*day').color('sales', '#BAE7FF-#1890FF-#0050B3')
Colors can also be a callback function, the parameters of the callback are the data field values. If the function is going to map multiple data fields, parameters will be passed in the declared order, for example:

const data = [
{ fruit: "apple", price: 2 },
{ fruit: "orange", price: 1.5 },
{ fruit: "banana", price: 0.8 }
];
const chart = new F2.Chart({
id: 'mountNode',
pixelRatio: window.devicePixelRatio
});
chart.source(data);
chart.interval().position('fruit*price').color('fruit', val => {
if (val === 'apple') {
return '#CD0110';
} else if (val === 'orange') {
return '#F88825';
} else if (val === 'banana') {
return '#FAD639';
}
});
chart.render();
shape()
shape()
A method of mapping data values ​​to the shape of the geometry.
chart.point().shape('circle'); // a specific shape
chart.point().shape('fieldName'); // use the built-in shapes to map the data field
chart.point().shape('fieldName', [ 'circle', 'hollowCircle', 'rect' ]); // specify shapes
chart.point().shape('fieldName', (type) => { // use callback do the mapping
if(type === 'a') {
return 'circle';
}
return 'rect';
});
shape(shapeName)
shapeName
: String
Specify the shape that the geometry draws. The following table lists the shapes supported by different geometry types:
Geometry Type
Supported Shape
Description
point
'circle', 'hollowCircle', 'rect'
'circle' is default
line
'line', 'smooth', 'dash'
'line' is default, 'dash': dash line, 'smooth': smooth line
area
'area', 'smooth'
'area' is default
interval
'rect'
polygon
'polygon'
schema
'candle'
only candlestick chart is supported currently
chart.point().position('x*y').shape('rect'); // all the points's shapes are rectangles
shape(fieldName, shapes)
fieldName
: StringThe name of the data field that maps to the shape attribute.
shapes
: String / Array / Functionshapes
is an optional parameter.If this parameter is not provided, shapes will be rendered defaultly.
// use default point shapes, 'circle', 'hollowCircle', 'rect' chart.point().position('x*y').shape('z');
Users can also specify shapes to render. The specific shapes are listed above.
chart.point().position('x*y').shape('z', [ 'circle', 'rect' ]); // specify shapes
shapes
can also be a callback function, the parameters of the callback are the data field values. If the function is going to map multiple data fields, parameters will be passed in the declared order, for example:

const data = [
{ fruit: "apple", price: 2 },
{ fruit: "orange", price: 1.5 },
{ fruit: "banana", price: 0.8 }
];
const chart = new F2.Chart({
id: 'mountNode',
pixelRatio: window.devicePixelRatio
});
chart.source(data);
chart.point().position('fruit*price').shape('fruit', val => {
if (val === 'apple') {
return 'rect';
} else if (val === 'orange') {
return 'hollowCircle';
} else if (val === 'banana') {
return 'circle';
}
});
chart.render();
size()
A method of mapping data values ​​to the size of the geometry.
chart.point().size(10); // specific size
chart.point().size('fieldName'); // the value mapped to the size
chart.point().size('fieldName', [ 0, 10 ]); // the value mapped to the size, and specify maximum and minimum values
chart.point().size('fieldName', val => { // 回调函数
if (val > 5) {
return 10;
}
return 5;
});
size(field, [ min, max ])
Map the size of the geometry based on the value of the field, the maximum value (default to 10) and minimum value (default to 1) are specified by max and min.
// map the value in field z to size, the maximum mapped value is 100, minimum mapped value is 10.
chart.point().position('x*y').size('z', [ 10, 100 ]);
size(field, callback)
Use callback function to calculate the size of the geometry.
chart.point().position('x*y').size('z', value => {
if (value === 1) {
return 5;
}
return 10;
});
adjust()
adjust()
Declare the data adjustment method for the geometry instance, which can be used to draw stacked charts, grouped charts, etc.
F2 supports two kinds of data adjustment: stack
and dodge
.
chart.interval().adjust('stack');
chart.interval().adjust({
type: 'stack'
});
chart.interval().adjust([{
type: 'dodge',
marginRatio: 0, // Values from 0 to 1 are used to adjust the space between bars in a group
}]);

const data =[
{ city: 'London', month: 'Jan.', rainfall: 18.9 },
{ city: 'London', month: 'Feb.', rainfall: 28.8 },
{ city: 'London', month: 'Mar.', rainfall: 39.3 },
{ city: 'London', month: 'Apr.', rainfall: 81.4 },
{ city: 'London', month: 'May.', rainfall: 47 },
{ city: 'London', month: 'Jun.', rainfall: 20.3 },
{ city: 'London', month: 'Jul.', rainfall: 24 },
{ city: 'London', month: 'Aug.', rainfall: 35.6 },
{ city: 'Berlin', month: 'Jan.', rainfall: 12.4 },
{ city: 'Berlin', month: 'Feb.', rainfall: 23.2 },
{ city: 'Berlin', month: 'Mar.', rainfall: 34.5 },
{ city: 'Berlin', month: 'Apr.', rainfall: 99.7 },
{ city: 'Berlin', month: 'May.', rainfall: 52.6 },
{ city: 'Berlin', month: 'Jun.', rainfall: 35.5 },
{ city: 'Berlin', month: 'Jul.', rainfall: 37.4 },
{ city: 'Berlin', month: 'Aug.', rainfall: 42.4 }
];
const chart = new F2.Chart({
id: 'mountNode',
pixelRatio: window.devicePixelRatio
});
chart.source(data, {
rainfall: {
tickCount: 5
}
});
chart.interval().position('month*rainfall').color('city').adjust('stack');
chart.render();
style()
style()
Used to configure the display the geometries, see Canvas for more details.
There are two ways to use style()
method:
style(cfg)
style(cfg)
cfg
: Object, configuration for graphical attributes, see Canvas for more details.
chart.line().style({ // style for all shapes
lineWidth: 2
});
style(field, cfg)
style(field, cfg)
Mapping from data fields to style configuration.
field
: String, field name of datacfg
: Object, configuration for graphical attributes, callback is also supported here
chart.ling().style('city', {
lineDash(val) {
if (val === 'HZ') {
return [ 2, 2 ];
}
return null;
}
})
animate()
animate()
Configuration for geometry's animation.Includes animation type, duration time and easing function and so on.
chart.point().animate(false); // turn off animation
chart.point().animate({
appear: {
animation: {String}, // animation name
easing: {String}, // easing function
duration: {Number}, // duration time of the animation, ms is the unit
delay: {Number} // delay of the animation, ms is the unit
}, // entrance animation
update: {
animation: {String},
easing: {String},
duration: {Number},
delay: {Number}
}, // updating animation
enter: {
animation: {String},
easing: {String},
duration: {Number},
delay: {Number}
}, // animation for the change of the source data
leave: {
animation: {String},
easing: {String},
duration: {Number},
delay: {Number}
} // destroy animation
});
For more about animations, see Animation.
Last updated