@opitzconsulting/pie-chart
Version:
animated pie chart component
641 lines (634 loc) • 74 kB
JavaScript
import { Injectable, Component, Input, ElementRef, Output, EventEmitter, NgModule, defineInjectable } from '@angular/core';
import { select, interpolate, arc } from 'd3';
import { BrowserModule } from '@angular/platform-browser';
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class PieChartService {
constructor() { }
}
PieChartService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] },
];
/** @nocollapse */
PieChartService.ctorParameters = () => [];
/** @nocollapse */ PieChartService.ngInjectableDef = defineInjectable({ factory: function PieChartService_Factory() { return new PieChartService(); }, token: PieChartService, providedIn: "root" });
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class PieChartComponent {
/**
* constructor
* @param {?} element
*/
constructor(element) {
this.element = element;
/**
* chart data, which should be displayed
*/
this.data = [];
/**
* chart width in pixel
*/
this.width = 250;
/**
* chart height in pixel
*/
this.height = 250;
/**
* duration of animation transition
*/
this.duration = 1000;
/**
* inner spacing in pixel, if greater than 0 it defines the radius of the empty circle in the middle
*/
this.innerSpacing = 0;
/**
* outer spacing in pixel
*/
this.outerSpacing = 1;
/**
* fired when user clicks on a chart entry
*/
this.chartClick = new EventEmitter();
/**
* fired when user hovers a chart entry
*/
this.chartHover = new EventEmitter();
/**
* current chart data with angle and path definitions, it will be consistent to the representation
*/
this.curData = [];
/**
* end chart data with angle and path definitions, it will representate the end state and used only for interpolation
*/
this.endData = [];
/**
* copy of last processed data, used to identify changes in ngDoCheck that Angular overlooked
*/
this.lastData = [];
/**
* Function for interrupt a running chart animation. Necessary because if transition is still active
* when a new transition is started, tween factory function from previos transition will still be fired
* until end of transition is reached. For entries which have a started transition the tween factory
* function will be fired multiple times with different tween interpolation range!
*/
this.interrupt = undefined;
}
/**
* Creates a deep copy of an variable. Do not use this function with recursive objects or
* browser objects like window or document.
* ToDo: should be outsourced.
* @template T
* @param {?} v
* @return {?}
*/
deepCopy(v) {
return JSON.parse(JSON.stringify(v));
}
;
;
/**
* @return {?}
*/
ngOnInit() {
this.tooltip = /** @type {?} */ (this.element.nativeElement.querySelector('div.pie-chart-tooltip'));
}
/**
* Fired when Angular (re-)sets data-bound properties. This function does not fire when changed data in bound objects or arrays.
* Angular only checks references.
* @param {?} changes
* @return {?}
*/
ngOnChanges(changes) {
// check if entries in bound data property has changed
this.detectDataChange();
}
;
/**
* Fired during every change detection run to detect and act upon changes that Angular can't or won't detect on its own.
* @return {?}
*/
ngDoCheck() {
// check if entries in bound data property has changed
this.detectDataChange();
}
;
/**
* Checks whether the data property has changed. This function also check whether only an item property has
* changed. In case of change the chart will be rendered.
* @return {?}
*/
detectDataChange() {
// fast check: if items were added or removed
let /** @type {?} */ dataChanged = (this.data.length !== this.lastData.length);
// detail check:
if (dataChanged === false) {
// loop all items
for (let /** @type {?} */ idx = 0; idx < this.data.length; ++idx) {
const /** @type {?} */ a = this.data[idx];
const /** @type {?} */ b = this.lastData[idx];
// check internal item properties
dataChanged = dataChanged || (a.caption !== b.caption || a.color !== b.color || a.value !== b.value);
// for optimization, stop if change detected
if (dataChanged)
break;
}
}
// if change detected
if (dataChanged) {
// render chart
this.render();
// copy current data to identify changes
this.lastData = this.deepCopy(this.data);
}
}
;
/**
* Generates a random color for a chart item.
* @param {?} value
* @return {?}
*/
generateRandomColor(value) {
const /** @type {?} */ hue2rgb = (p, q, t) => {
if (t < 0)
t += 1;
if (t > 1)
t -= 1;
if (t < 1 / 6)
return p + (q - p) * 6 * t;
if (t < 1 / 2)
return q;
if (t < 2 / 3)
return p + (q - p) * (2 / 3 - t) * 6;
return p;
};
// make sure, generated color does not exists yet in data array
let /** @type {?} */ color;
let /** @type {?} */ uniqueColorGenerated = false;
while (uniqueColorGenerated === false) {
const /** @type {?} */ h = (Math.random() + 0.618033988749895) % 1;
const /** @type {?} */ s = .5;
const /** @type {?} */ l = .6;
let /** @type {?} */ q = l + s - l * s;
let /** @type {?} */ p = 2 * l - q;
const /** @type {?} */ r = hue2rgb(p, q, h + 1 / 3);
const /** @type {?} */ g = hue2rgb(p, q, h);
const /** @type {?} */ b = hue2rgb(p, q, h - 1 / 3);
color = '#'
+ Math.round(r * 255).toString(16)
+ Math.round(g * 255).toString(16)
+ Math.round(b * 255).toString(16);
uniqueColorGenerated = (this.data.map((d) => d.color).filter((d) => d === color).length === 0);
}
return color;
}
;
/**
* generates a pie chart item definition
* @param {?} item
* @param {?} index
* @param {?} value
* @param {?} startAngle
* @param {?} endAngle
* @return {?}
*/
generatePieArcData(item, index, value, startAngle, endAngle) {
// generate definition
const /** @type {?} */ result = {
data: item,
index: index,
value: value,
startAngle: startAngle,
endAngle: endAngle,
padAngle: 0,
innerRadius: this.radius - 40,
outerRadius: this.radius
};
// generate svg path d-attribute from definition
(/** @type {?} */ (result.data)).path = this.pathGenerator(result);
// return definition
return result;
}
;
/**
* Checks whether items were deleted and initiate delete transition for these items.
* @return {?}
*/
detectDeletedEntries() {
// loop current state entries
this.curData.forEach((curItem, idx) => {
// only check if current entry is not marked as deleted
if (curItem.data.deleted !== true) {
// check if entry not exists anymore
const /** @type {?} */ isDeleted = (this.data.filter((item) => item.caption === curItem.data.caption).length === 0);
// if entry is deleted
if (isDeleted) {
// mark entry in current state as deleted
this.curData[idx].data.deleted = true;
// mark entry in end state as deleted and set value to 0 for transtion
this.endData[idx].data.deleted = true;
this.endData[idx].value = 0;
}
}
});
}
;
/**
* Checks whether items were inserted and initiate insert transition for these items.
* @return {?}
*/
detectInsertedEntries() {
// loop given data array
this.data.forEach((item, idx) => {
// check if entry is new
const /** @type {?} */ isInserted = (this.curData.filter((curItem) => curItem.data.deleted !== true && curItem.data.caption === item.caption).length === 0);
// if entry is new
if (isInserted) {
{
const /** @type {?} */ d = this.generatePieArcData(this.deepCopy(item), idx, 0, -1, -1);
this.curData.splice(idx, 0, d);
}
{
const /** @type {?} */ d = this.generatePieArcData(this.deepCopy(item), idx, item.value, -1, -1);
this.endData.splice(idx, 0, d);
}
}
});
}
;
/**
* Checks whether items were moved and initiate transition for these items.
* @return {?}
*/
detectMovedEntries() {
// separate index in current state array
let /** @type {?} */ curIndex = 0;
// loop data array
for (let /** @type {?} */ index = 0; index < this.data.length; ++index) {
// find next index in current state array, skip items marked as deleted
while (this.curData[curIndex].data.deleted)
++curIndex;
// check if item is moved by comparing captions
if (this.data[index].caption !== this.curData[curIndex].data.caption) {
{
// mark item in current state array as deleted
this.curData[curIndex].data.deleted = true;
// mark item in end state array as deleted and set value to 0 for transition
this.endData[curIndex].data.deleted = true;
this.endData[curIndex].value = 0;
}
{
const /** @type {?} */ item = this.deepCopy(this.data[index]);
const /** @type {?} */ d = this.generatePieArcData(item, -1, 0, -1, -1);
this.curData.splice(curIndex, 0, d);
}
{
const /** @type {?} */ item = this.deepCopy(this.data[index]);
const /** @type {?} */ d = this.generatePieArcData(item, -1, item.value, -1, -1);
this.endData.splice(curIndex, 0, d);
}
// because of inserting item to the array's, increment index twice
++curIndex;
}
++curIndex;
}
}
;
/**
* Synchronize state arrays (curData / endData) with given items (data).
* @return {?}
*/
syncItems() {
// sync values and colors
this.data.forEach((item, index) => {
// find item index in state array's
let /** @type {?} */ curIndex = 0;
for (let /** @type {?} */ i = 0; i < this.curData.length; ++i) {
if (!this.curData[i].data.deleted && this.curData[i].data.caption === item.caption) {
curIndex = i;
break;
}
}
// update value in state entries
this.curData[curIndex].data.value = item.value;
this.endData[curIndex].data.value = item.value;
// update value in end state entry for transition
this.endData[curIndex].value = item.value;
// update color in end state entry for transition
this.endData[curIndex].data.color = item.color;
});
}
;
/**
* will be triggerd to animate chart changes.
* important! this method musst be called within a setTimeout function because of angulars
* rendering cycle.
* @return {?}
*/
animateChanges() {
// get svg element reference
const /** @type {?} */ svg = (/** @type {?} */ (this.element.nativeElement.querySelector('svg')));
// reference all path elements in svg element
const /** @type {?} */ paths = select(svg).selectAll('path');
// define interruption function to stop running animations
this.interrupt = () => {
// call paths interrupt method
paths.interrupt();
// delete interupt definition
delete this.interrupt;
};
// start path animation
paths
.transition()
.duration(this.duration)
.attrTween('pie-tween-dummy', (arg0, idx, nodeList) => {
// create interpolation functions to calculate step values
const /** @type {?} */ iValue = interpolate(this.curData[idx].value, this.endData[idx].value);
const /** @type {?} */ iStartAngle = interpolate(this.curData[idx].startAngle, this.endData[idx].startAngle);
const /** @type {?} */ iEndAngle = interpolate(this.curData[idx].endAngle, this.endData[idx].endAngle);
const /** @type {?} */ iColor = interpolate(this.curData[idx].data.color, this.endData[idx].data.color);
// return factory function for animation steps
return (t) => {
// interpolate values by given transition value
this.curData[idx].value = iValue(t);
this.curData[idx].startAngle = iStartAngle(t);
this.curData[idx].endAngle = iEndAngle(t);
this.curData[idx].data.color = iColor(t);
// generate new path
this.curData[idx].data.path = this.pathGenerator(this.curData[idx]);
// return empty string. This is only necessary for typescript compiler. Nothing should be changed here.
return '';
};
})
.on('end', (arg0, idx, nodeList) => {
// when transition is complete for the last item
if (idx === nodeList.length - 1) {
// remove as deleted marked entries
this.cleanStateItems();
// Delete interupt definition, because everything has finished and nothing can be interrupted.
delete this.interrupt;
}
});
}
;
/**
* Must be called after transition ends to remove entries in curData and endData which are marked
* as deleted.
* @return {?}
*/
cleanStateItems() {
// clean current state array
for (let /** @type {?} */ i = this.curData.length - 1; i >= 0; --i) {
if (this.curData[i].data.deleted === true) {
this.curData.splice(i, 1);
}
}
// clean end state array
for (let /** @type {?} */ i = this.endData.length - 1; i >= 0; --i) {
if (this.endData[i].data.deleted === true) {
this.endData.splice(i, 1);
}
}
}
;
/**
* Checks whether all items have assigned color values and if necessary completes colors in given data array.
* @return {?}
*/
initColors() {
// loop all entries
this.data.forEach((item) => {
// if no color is assigned
if (!item.color) {
// generate random color for item
item.color = this.generateRandomColor(item.value);
}
});
}
;
/**
* Returns maximal angle of current state items.
* @return {?}
*/
getMaxAngle() {
let /** @type {?} */ maxAngle = 0;
this.curData.forEach((curItem) => {
if (curItem.endAngle > maxAngle) {
maxAngle = curItem.endAngle;
}
});
return maxAngle;
}
;
/**
* Calculates angles for current and end state items.
* @param {?} maxAngle last maximal angle in current state to avoid "jumping" transitions
* @return {?}
*/
calculateAngles(maxAngle) {
{
// calculate sum of values
const /** @type {?} */ total = this.curData.reduce((p, c) => p + c.value, 0);
// loop items and calculate start and end angles, initialize rendering
let /** @type {?} */ lastAngle = 0;
this.curData.forEach((item, idx) => {
// calculate angles by last used maximal angle. without data (total=0) simulate 0 values, so draw items in clockwise direction.
const /** @type {?} */ nextAngle = lastAngle + ((maxAngle) / ((total === 0) ? 1 : total)) * item.value;
item.startAngle = lastAngle;
item.endAngle = nextAngle;
item.index = idx;
item.data.path = this.pathGenerator(item);
lastAngle = nextAngle;
});
}
{
// calculate sum of values
const /** @type {?} */ total = this.endData.reduce((p, c) => p + c.value, 0);
// loop items and calculate start and end angles, initialize rendering
let /** @type {?} */ lastAngle = 0;
this.endData.forEach((item, idx) => {
// calculate angles with circumference. without data (total=0) simulate 0 values, so draw items in anti-clockwise direction.
const /** @type {?} */ nextAngle = lastAngle + ((2 * Math.PI) / ((total === 0) ? 1 : total)) * item.value;
item.startAngle = lastAngle;
item.endAngle = nextAngle;
item.index = idx;
item.data.path = this.pathGenerator(item);
lastAngle = nextAngle;
});
}
}
;
/**
* fired when mouse enters a pie chart path element and shows tooltip
* @param {?} event
* @return {?}
*/
overPath(event) {
// get tooltip-text of path element
const /** @type {?} */ txt = (/** @type {?} */ (event.target)).getAttribute('tooltip');
// show tooltip and assign text
select(this.tooltip)
.html(txt)
.style('display', 'block')
.transition()
.duration(250)
.style('opacity', 1);
// get index
const /** @type {?} */ idx = parseInt((/** @type {?} */ (event.target)).getAttribute('idx'), 10);
// get caption of element
const /** @type {?} */ caption = this.curData[idx].data.caption;
// get original data by caption
const /** @type {?} */ item = this.data.filter((d) => d.caption === caption)[0];
// if data found then emit chart click event
if (item) {
this.chartHover.emit(item);
}
}
;
/**
* fired when mouse moves over a pie chart path element and adjusts tooltip
* @param {?} event
* @return {?}
*/
movePath(event) {
// aggregate scroll positions, because event.page* properties are relative to top left corner of document
let /** @type {?} */ offsetX = 0;
let /** @type {?} */ offsetY = 0;
let /** @type {?} */ element = (/** @type {?} */ (this.tooltip.parentElement));
while (element) {
offsetX += element.scrollLeft;
offsetY += element.scrollTop;
element = element.parentElement;
}
// adjust tooltip
select(this.tooltip)
.style('top', (event.pageY - offsetY + 10) + 'px')
.style('left', (event.pageX - offsetX + 10) + 'px');
}
;
/**
* fired when mouse leaves a pie chart path element and hides tooltip
* @param {?} event
* @return {?}
*/
outPath(event) {
// hide tooltip
select(this.tooltip)
.transition()
.duration(250)
.style('opacity', 0)
.on('end', () => {
select(this.tooltip).style('display', 'none');
});
}
;
/**
* fired when user clicks on a pie chart path element
* @param {?} event
* @return {?}
*/
clickPath(event) {
// get index
const /** @type {?} */ idx = parseInt((/** @type {?} */ (event.target)).getAttribute('idx'), 10);
// get caption of element
const /** @type {?} */ caption = this.curData[idx].data.caption;
// get original data by caption
const /** @type {?} */ item = this.data.filter((d) => d.caption === caption)[0];
// if data found then emit chart click event
if (item) {
this.chartClick.emit(item);
}
}
;
/**
* main rendering function
* @return {?}
*/
render() {
// interrupt possible running animations
if (this.interrupt)
this.interrupt();
// initialize chart colors
this.initColors();
// calculate radius
this.radius = Math.min(this.width, this.height) / 2;
// calculate middle of chart
this.center = `translate(${this.width / 2}, ${this.height / 2})`;
// create path generator
this.pathGenerator = arc().outerRadius(this.radius - this.outerSpacing).innerRadius(this.innerSpacing);
// get current maximal angle, necessary to avoid "jumping" transitions
const /** @type {?} */ maxAngle = this.getMaxAngle();
// check data array for deleted entries and assign transition configuration
this.detectDeletedEntries();
// check data array for inserted entries and assign transition configuration
this.detectInsertedEntries();
// check data array for moved entries and assign transition configuration
this.detectMovedEntries();
// synchronize data entries with current and end state entries
this.syncItems();
// calculate angles for current and end state entries
this.calculateAngles(maxAngle);
// important! use setTimeout because angular first must exec change detection
setTimeout(() => {
// start change animations
this.animateChanges();
}, 0);
}
;
}
PieChartComponent.decorators = [
{ type: Component, args: [{
selector: 'oc-pie-chart',
template: `<div class="pie-chart-tooltip"></div>
<svg [attr.width]="width" [attr.height]="height">
<g [attr.transform]="center">
<path *ngFor="let d of curData; let idx = index;" [attr.idx]="idx"
[attr.fill]="d.data.color" [attr.d]="d.data.path" [attr.tooltip]="d.data.caption"
(mouseover)="overPath($event)" (mousemove)="movePath($event);" (mouseout)="outPath($event)" (click)="clickPath($event)" />
</g>
</svg>`,
styles: [`div.pie-chart-tooltip{position:fixed;display:none;opacity:0;font:12px sans-serif;color:#fff;background-color:rgba(35,47,52,.8);padding:5px}path{opacity:.7;stroke:#fff;stroke-width:2px}path:hover{opacity:1;stroke:#e3e3e3}`]
},] },
];
/** @nocollapse */
PieChartComponent.ctorParameters = () => [
{ type: ElementRef }
];
PieChartComponent.propDecorators = {
data: [{ type: Input }],
width: [{ type: Input }],
height: [{ type: Input }],
duration: [{ type: Input }],
innerSpacing: [{ type: Input }],
outerSpacing: [{ type: Input }],
chartClick: [{ type: Output }],
chartHover: [{ type: Output }]
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
class PieChartModule {
}
PieChartModule.decorators = [
{ type: NgModule, args: [{
imports: [BrowserModule],
declarations: [PieChartComponent],
exports: [PieChartComponent]
},] },
];
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
/**
* @fileoverview added by tsickle
* @suppress {checkTypes} checked by tsc
*/
export { PieChartService, PieChartComponent, PieChartModule };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"opitzconsulting-pie-chart.js.map","sources":["ng://@opitzconsulting/pie-chart/lib/pie-chart.service.ts","ng://@opitzconsulting/pie-chart/lib/pie-chart.component.ts","ng://@opitzconsulting/pie-chart/lib/pie-chart.module.ts"],"sourcesContent":["import { Injectable } from '@angular/core';\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PieChartService {\r\n\r\n  constructor() { }\r\n}\r\n","import { Component, Input, OnChanges, DoCheck, ElementRef, SimpleChanges, OnInit, Output, EventEmitter } from '@angular/core';\r\n\r\nimport * as d3 from 'd3';\r\n\r\n/** chart item properties */\r\nexport interface PieChartData {\r\n  /** value of item */\r\n  value: number;\r\n  /** caption of item (must be unique) */\r\n  caption: string;\r\n  /** optional color of item (if not set, generated automatically) */\r\n  color?: string;\r\n}\r\n\r\n/** internal chart item properties */\r\nexport interface InternalPieChartData extends PieChartData {\r\n  /** svg path for item */\r\n  path?: string;\r\n  /** delete flag for removing after transition */\r\n  deleted?: boolean;\r\n}\r\n\r\n/** internal type for optimization */\r\nexport type PieArcData = d3.PieArcDatum<InternalPieChartData> & d3.DefaultArcObject;\r\n\r\n@Component({\r\n  selector: 'oc-pie-chart',\r\n  template: `<div class=\"pie-chart-tooltip\"></div>\r\n<svg [attr.width]=\"width\" [attr.height]=\"height\">\r\n    <g [attr.transform]=\"center\">\r\n        <path *ngFor=\"let d of curData; let idx = index;\" [attr.idx]=\"idx\" \r\n            [attr.fill]=\"d.data.color\" [attr.d]=\"d.data.path\" [attr.tooltip]=\"d.data.caption\"\r\n            (mouseover)=\"overPath($event)\" (mousemove)=\"movePath($event);\" (mouseout)=\"outPath($event)\" (click)=\"clickPath($event)\" />\r\n    </g>\r\n</svg>`,\r\n  styles: [`div.pie-chart-tooltip{position:fixed;display:none;opacity:0;font:12px sans-serif;color:#fff;background-color:rgba(35,47,52,.8);padding:5px}path{opacity:.7;stroke:#fff;stroke-width:2px}path:hover{opacity:1;stroke:#e3e3e3}`]\r\n})\r\nexport class PieChartComponent implements OnInit, OnChanges, DoCheck {\r\n  /** chart data, which should be displayed */\r\n  @Input() data: Array<PieChartData> = [];\r\n  /** chart width in pixel */\r\n  @Input() width = 250;\r\n  /** chart height in pixel */\r\n  @Input() height = 250;\r\n  /** duration of animation transition */\r\n  @Input() duration = 1000;\r\n  /** inner spacing in pixel, if greater than 0 it defines the radius of the empty circle in the middle */\r\n  @Input() innerSpacing = 0;\r\n  /** outer spacing in pixel */\r\n  @Input() outerSpacing = 1;\r\n  /** fired when user clicks on a chart entry */\r\n  @Output() chartClick: EventEmitter<PieChartData> = new EventEmitter();\r\n  /** fired when user hovers a chart entry */\r\n  @Output() chartHover: EventEmitter<PieChartData> = new EventEmitter();\r\n\r\n  /** pie chart radius in pixel */\r\n  public radius: number;\r\n  /** transform-attribute to center chart vertical and horizontal */\r\n  public center: string;\r\n  /** current chart data with angle and path definitions, it will be consistent to the representation */\r\n  public curData: PieArcData[] = [];\r\n  /** end chart data with angle and path definitions, it will representate the end state and used only for interpolation */\r\n  private endData: PieArcData[] = [];\r\n  /** path generator function (internal use only) */\r\n  protected pathGenerator: d3.Arc<any, d3.DefaultArcObject>;\r\n  /** copy of last processed data, used to identify changes in ngDoCheck that Angular overlooked */\r\n  private lastData: Array<PieChartData> = [];\r\n\r\n  /**\r\n   * Creates a deep copy of an variable. Do not use this function with recursive objects or\r\n   * browser objects like window or document.\r\n   * ToDo: should be outsourced.\r\n   * @param v \r\n   */\r\n  protected deepCopy<T>(v: T): T {\r\n    return JSON.parse(JSON.stringify(v));\r\n  };\r\n\r\n  /**\r\n   * constructor\r\n   * @param element \r\n   */\r\n  constructor(\r\n    private element: ElementRef\r\n  ) {};\r\n\r\n  ngOnInit() {\r\n    this.tooltip = this.element.nativeElement.querySelector('div.pie-chart-tooltip') as HTMLDivElement;\r\n  }\r\n\r\n  /**\r\n   * Fired when Angular (re-)sets data-bound properties. This function does not fire when changed data in bound objects or arrays.\r\n   * Angular only checks references.\r\n   * @param changes \r\n   */\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    // check if entries in bound data property has changed\r\n    this.detectDataChange();\r\n  };\r\n\r\n  /**\r\n   * Fired during every change detection run to detect and act upon changes that Angular can't or won't detect on its own.\r\n   */\r\n  ngDoCheck() {\r\n    // check if entries in bound data property has changed\r\n    this.detectDataChange();\r\n  };\r\n\r\n  /**\r\n   * Checks whether the data property has changed. This function also check whether only an item property has\r\n   * changed. In case of change the chart will be rendered.\r\n   */\r\n  protected detectDataChange() {\r\n    // fast check: if items were added or removed\r\n    let dataChanged = (this.data.length !== this.lastData.length);\r\n    // detail check:\r\n    if(dataChanged === false){\r\n      // loop all items\r\n      for(let idx=0; idx<this.data.length; ++idx){\r\n        const a = this.data[idx];\r\n        const b = this.lastData[idx];\r\n        // check internal item properties\r\n        dataChanged = dataChanged || (a.caption !== b.caption || a.color !== b.color || a.value !== b.value);\r\n        // for optimization, stop if change detected\r\n        if(dataChanged) break;\r\n      }\r\n    }\r\n    // if change detected\r\n    if(dataChanged){\r\n      // render chart\r\n      this.render();\r\n      // copy current data to identify changes\r\n      this.lastData = this.deepCopy(this.data);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Generates a random color for a chart item.\r\n   */\r\n  protected generateRandomColor(value: number): string {\r\n    const hue2rgb = (p: number, q: number, t: number) => {\r\n      if(t < 0) t += 1; \r\n      if(t > 1) t -= 1; \r\n      if(t < 1/6) return p + (q - p) * 6 * t;\r\n      if(t < 1/2) return q;\r\n      if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;\r\n      return p;\r\n    };\r\n    // make sure, generated color does not exists yet in data array\r\n    let color;\r\n    let uniqueColorGenerated = false;\r\n    while(uniqueColorGenerated === false){\r\n      const h = (Math.random() + 0.618033988749895) % 1;\r\n      const s = .5;\r\n      const l = .6;\r\n      let q = l + s - l * s;\r\n      let p = 2 * l - q;\r\n      const r = hue2rgb(p, q, h + 1/3);\r\n      const g = hue2rgb(p, q, h);\r\n      const b = hue2rgb(p, q, h - 1/3);\r\n      color = '#' \r\n        + Math.round(r * 255).toString(16)\r\n        + Math.round(g * 255).toString(16)\r\n        + Math.round(b * 255).toString(16);\r\n      uniqueColorGenerated = (this.data.map( (d) => d.color).filter( (d) => d === color).length === 0);\r\n    }\r\n    return color;\r\n  };\r\n\r\n  /**\r\n   * generates a pie chart item definition\r\n   * @param item \r\n   * @param index \r\n   * @param value \r\n   * @param startAngle \r\n   * @param endAngle \r\n   */\r\n  protected generatePieArcData(item: PieChartData, index: number, value: number, startAngle: number, endAngle: number): PieArcData {\r\n    // generate definition\r\n    const result = {\r\n      data: item,\r\n      index: index,\r\n      value: value,\r\n      startAngle: startAngle,\r\n      endAngle: endAngle,\r\n      padAngle: 0,\r\n      innerRadius: this.radius - 40,\r\n      outerRadius: this.radius\r\n    };\r\n    // generate svg path d-attribute from definition\r\n    (result.data as InternalPieChartData).path = this.pathGenerator(result);\r\n    // return definition\r\n    return result;\r\n  };\r\n\r\n  /**\r\n   * Checks whether items were deleted and initiate delete transition for these items.\r\n   */\r\n  protected detectDeletedEntries() {\r\n    // loop current state entries\r\n    this.curData.forEach( (curItem, idx) => {\r\n      // only check if current entry is not marked as deleted\r\n      if(curItem.data.deleted!==true){\r\n        // check if entry not exists anymore\r\n        const isDeleted = (this.data.filter( (item) => item.caption === curItem.data.caption).length === 0);\r\n        // if entry is deleted\r\n        if(isDeleted){\r\n          // mark entry in current state as deleted\r\n          this.curData[idx].data.deleted = true;\r\n          // mark entry in end state as deleted and set value to 0 for transtion\r\n          this.endData[idx].data.deleted = true;\r\n          this.endData[idx].value = 0;\r\n        }\r\n      }\r\n    });\r\n  };\r\n\r\n  /**\r\n   * Checks whether items were inserted and initiate insert transition for these items.\r\n   */\r\n  protected detectInsertedEntries(): void {\r\n    // loop given data array\r\n    this.data.forEach( (item, idx) => {\r\n      // check if entry is new\r\n      const isInserted = (this.curData.filter( (curItem) => curItem.data.deleted!==true && curItem.data.caption === item.caption).length===0);\r\n      // if entry is new\r\n      if(isInserted){\r\n        // generate current state entry with value of 0 for transition\r\n        {\r\n          const d = this.generatePieArcData(this.deepCopy(item), idx, 0, -1, -1);\r\n          this.curData.splice(idx, 0, d);\r\n        }\r\n        // generate end state entry with given value\r\n        {\r\n          const d = this.generatePieArcData(this.deepCopy(item), idx, item.value, -1, -1);\r\n          this.endData.splice(idx, 0, d);\r\n        }\r\n      }\r\n    });\r\n  };\r\n\r\n  /**\r\n   * Checks whether items were moved and initiate transition for these items.\r\n   */\r\n  protected detectMovedEntries(): void {\r\n    // separate index in current state array\r\n    let curIndex = 0;\r\n    // loop data array\r\n    for(let index=0; index<this.data.length; ++index){\r\n      // find next index in current state array, skip items marked as deleted\r\n      while(this.curData[curIndex].data.deleted) ++curIndex; \r\n      // check if item is moved by comparing captions\r\n      if(this.data[index].caption !== this.curData[curIndex].data.caption){\r\n        // updating state items\r\n        {\r\n          // mark item in current state array as deleted\r\n          this.curData[curIndex].data.deleted = true;\r\n          // mark item in end state array as deleted and set value to 0 for transition\r\n          this.endData[curIndex].data.deleted = true;\r\n          this.endData[curIndex].value = 0;\r\n        }\r\n        // insert entry in current state array with value 0 for transition\r\n        {\r\n          const item = this.deepCopy(this.data[index]);\r\n          const d = this.generatePieArcData(item, -1, 0, -1, -1);\r\n          this.curData.splice(curIndex, 0, d);\r\n        }\r\n        // insert entry in end state array with given value\r\n        {\r\n          const item = this.deepCopy(this.data[index]);\r\n          const d = this.generatePieArcData(item, -1, item.value, -1, -1);\r\n          this.endData.splice(curIndex, 0, d);\r\n        }\r\n        // because of inserting item to the array's, increment index twice\r\n        ++curIndex;\r\n      }\r\n      ++curIndex;\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Synchronize state arrays (curData / endData) with given items (data).\r\n   */\r\n  protected syncItems(): void {\r\n    // sync values and colors\r\n    this.data.forEach( (item, index) => {\r\n      // find item index in state array's\r\n      let curIndex = 0;\r\n      for(let i=0; i<this.curData.length; ++i){\r\n        if(!this.curData[i].data.deleted && this.curData[i].data.caption === item.caption){\r\n          curIndex = i;\r\n          break;\r\n        }\r\n      }\r\n      // update value in state entries\r\n      this.curData[curIndex].data.value = item.value;\r\n      this.endData[curIndex].data.value = item.value;\r\n      // update value in end state entry for transition\r\n      this.endData[curIndex].value = item.value;\r\n      // update color in end state entry for transition\r\n      this.endData[curIndex].data.color = item.color;\r\n    });\r\n  };\r\n\r\n  /**\r\n   * Function for interrupt a running chart animation. Necessary because if transition is still active\r\n   * when a new transition is started, tween factory function from previos transition will still be fired \r\n   * until end of transition is reached. For entries which have a started transition the tween factory\r\n   * function will be fired multiple times with different tween interpolation range!\r\n   */\r\n  protected interrupt: Function = undefined;\r\n\r\n  /**\r\n   * will be triggerd to animate chart changes.\r\n   * important! this method musst be called within a setTimeout function because of angulars \r\n   * rendering cycle.\r\n   */\r\n  protected animateChanges(): void {\r\n    // get svg element reference\r\n    const svg = (this.element.nativeElement.querySelector('svg') as SVGElement);\r\n    // reference all path elements in svg element\r\n    const paths = d3.select(svg).selectAll('path');\r\n    // define interruption function to stop running animations\r\n    this.interrupt = () => {\r\n      // call paths interrupt method\r\n      paths.interrupt();\r\n      // delete interupt definition\r\n      delete this.interrupt;\r\n    };\r\n    // start path animation\r\n    paths\r\n      .transition()\r\n      .duration(this.duration)\r\n      // Use d3 attrTween transition method with dummy attribute. Make sure the dummy attribute does not\r\n      // exists at path elements!\r\n      .attrTween('pie-tween-dummy', (arg0, idx, nodeList) => {\r\n        // create interpolation functions to calculate step values\r\n        const iValue = d3.interpolate(this.curData[idx].value, this.endData[idx].value);\r\n        const iStartAngle = d3.interpolate(this.curData[idx].startAngle, this.endData[idx].startAngle);\r\n        const iEndAngle = d3.interpolate(this.curData[idx].endAngle, this.endData[idx].endAngle);\r\n        const iColor = d3.interpolate(this.curData[idx].data.color, this.endData[idx].data.color);\r\n        // return factory function for animation steps\r\n        return (t) => {\r\n          // interpolate values by given transition value\r\n          this.curData[idx].value = iValue(t);\r\n          this.curData[idx].startAngle = iStartAngle(t);\r\n          this.curData[idx].endAngle = iEndAngle(t);\r\n          this.curData[idx].data.color = iColor(t);\r\n          // generate new path\r\n          this.curData[idx].data.path = this.pathGenerator(this.curData[idx]);\r\n          // return empty string. This is only necessary for typescript compiler. Nothing should be changed here.\r\n          return '';\r\n        };\r\n      })\r\n      // when transition is complete\r\n      .on('end', (arg0, idx, nodeList) => {\r\n        // when transition is complete for the last item\r\n        if(idx===nodeList.length-1){\r\n          // remove as deleted marked entries\r\n          this.cleanStateItems();\r\n          // Delete interupt definition, because everything has finished and nothing can be interrupted.\r\n          delete this.interrupt;\r\n        }\r\n      });\r\n  };\r\n\r\n  /**\r\n   * Must be called after transition ends to remove entries in curData and endData which are marked\r\n   * as deleted.\r\n   */\r\n  protected cleanStateItems(): void {\r\n    // clean current state array\r\n    for(let i=this.curData.length-1; i>=0; --i){\r\n      if(this.curData[i].data.deleted===true){\r\n        this.curData.splice(i, 1);\r\n      }\r\n    }\r\n    // clean end state array\r\n    for(let i=this.endData.length-1; i>=0; --i){\r\n      if(this.endData[i].data.deleted===true){\r\n        this.endData.splice(i,1);\r\n      }\r\n    }\r\n  };\r\n\r\n  /**\r\n   * Checks whether all items have assigned color values and if necessary completes colors in given data array.\r\n   */\r\n  protected initColors(): void {\r\n    // loop all entries\r\n    this.data.forEach( (item) => {\r\n      // if no color is assigned\r\n      if(!item.color){\r\n        // generate random color for item\r\n        item.color = this.generateRandomColor(item.value);\r\n      }\r\n    });\r\n  };\r\n\r\n  /**\r\n   * Returns maximal angle of current state items.\r\n   */\r\n  protected getMaxAngle(): number {\r\n    let maxAngle = 0;\r\n    this.curData.forEach( (curItem) => { \r\n      if(curItem.endAngle > maxAngle){\r\n        maxAngle = curItem.endAngle;\r\n      }\r\n    });\r\n    return maxAngle;\r\n  };\r\n\r\n  /**\r\n   * Calculates angles for current and end state items.\r\n   * @param maxAngle last maximal angle in current state to avoid \"jumping\" transitions\r\n   */\r\n  protected calculateAngles(maxAngle: number): void {\r\n    // calculate angles for current state items\r\n    {\r\n      // calculate sum of values\r\n      const total = this.curData.reduce((p, c) => p + c.value, 0);\r\n      // loop items and calculate start and end angles, initialize rendering\r\n      let lastAngle = 0;\r\n      this.curData.forEach( (item, idx) => {\r\n        // calculate angles by last used maximal angle. without data (total=0) simulate 0 values, so draw items in clockwise direction.\r\n        const nextAngle = lastAngle + ((maxAngle) / ((total===0)?1:total)) * item.value;\r\n        item.startAngle = lastAngle;\r\n        item.endAngle = nextAngle;\r\n        item.index = idx;\r\n        item.data.path = this.pathGenerator(item);\r\n        lastAngle = nextAngle;\r\n      });\r\n    }\r\n    // calculate angles for end state items\r\n    {\r\n      // calculate sum of values\r\n      const total = this.endData.reduce((p, c) => p + c.value, 0);\r\n      // loop items and calculate start and end angles, initialize rendering\r\n      let lastAngle = 0;\r\n      this.endData.forEach( (item, idx) => {\r\n        // calculate angles with circumference. without data (total=0) simulate 0 values, so draw items in anti-clockwise direction.\r\n        const nextAngle = lastAngle + ((2 * Math.PI) / ((total===0)?1:total)) * item.value;\r\n        item.startAngle = lastAngle;\r\n        item.endAngle = nextAngle;\r\n        item.index = idx;\r\n        item.data.path = this.pathGenerator(item);\r\n        lastAngle = nextAngle;\r\n      });\r\n    }\r\n  };\r\n\r\n  /** reference to tooltip div element */\r\n  private tooltip: HTMLDivElement;\r\n\r\n  /**\r\n   * fired when mouse enters a pie chart path element and shows tooltip\r\n   * @param event \r\n   */\r\n  public