import { Injectable, RendererFactory2, ViewChild, Component, Input, Output, EventEmitter, HostListener, ElementRef, Directive, NgModule } from '@angular/core';
import { __generator, __spread, __assign } from 'tslib';
import { randomUniform } from 'd3-random';
import { select } from 'd3-selection';
import { line, curveBasis } from 'd3-shape';
import { BrowserModule } from '@angular/platform-browser';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsCanvasService = /** @class */ (function () {
    function NlsCanvasService(rendererFactory) {
        this.rendererFactory = rendererFactory;
        this.renderer = rendererFactory.createRenderer(null, null);
    }
    Object.defineProperty(NlsCanvasService.prototype, "get", {
        get: /**
         * @return {?}
         */
        function () {
            return this.canvas;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @param {?} el
     * @return {?}
     */
    NlsCanvasService.prototype.set = /**
     * @param {?} el
     * @return {?}
     */
    function (el) {
        this.canvas = el;
    };
    /**
     * @return {?}
     */
    NlsCanvasService.prototype.adjustToWindow = /**
     * @return {?}
     */
    function () {
        if (this.canvas) {
            this.renderer.setStyle(this.canvas, 'width', this.canvas.innerWidth);
            this.renderer.setStyle(this.canvas, 'height', this.canvas.innerHeight);
        }
    };
    NlsCanvasService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    NlsCanvasService.ctorParameters = function () { return [
        { type: RendererFactory2 }
    ]; };
    return NlsCanvasService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsHistoryService = /** @class */ (function () {
    function NlsHistoryService() {
        this.history = [];
    }
    /**
     * @param {?} graphs
     * @param {?} config
     * @return {?}
     */
    NlsHistoryService.prototype.save = /**
     * @param {?} graphs
     * @param {?} config
     * @return {?}
     */
    function (graphs, config) {
        this.history.push({
            date: new Date(),
            graphs: graphs,
            config: config,
            hash: this.hash(graphs)
        });
    };
    /**
     * @param {?} graphs
     * @return {?}
     */
    NlsHistoryService.prototype.hash = /**
     * @param {?} graphs
     * @return {?}
     */
    function (graphs) {
        return btoa(JSON.stringify(graphs));
    };
    /**
     * @return {?}
     */
    NlsHistoryService.prototype.list = /**
     * @return {?}
     */
    function () {
        return this.history;
    };
    NlsHistoryService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    NlsHistoryService.ctorParameters = function () { return []; };
    return NlsHistoryService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsMathService = /** @class */ (function () {
    function NlsMathService() {
    }
    /**
     * Calculate distance between to points with coordinates.
     * @param {?} a
     * @param {?} b
     * @return {?}
     */
    NlsMathService.prototype.Δ = /**
     * Calculate distance between to points with coordinates.
     * @param {?} a
     * @param {?} b
     * @return {?}
     */
    function (a, b) {
        return Math.pow(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2), 0.5);
    };
    /**
     * @param {?} point
     * @param {?} matrix
     * @return {?}
     */
    NlsMathService.prototype.getClosestCenter = /**
     * @param {?} point
     * @param {?} matrix
     * @return {?}
     */
    function (point, matrix) {
        if (this.Δ(point, matrix.start) < this.Δ(point, matrix.end)) {
            return matrix.start;
        }
        else {
            return matrix.end;
        }
    };
    /**
     * @param {?} point
     * @param {?} matrix
     * @return {?}
     */
    NlsMathService.prototype.getFarestCenter = /**
     * @param {?} point
     * @param {?} matrix
     * @return {?}
     */
    function (point, matrix) {
        if (this.Δ(point, matrix.start) > this.Δ(point, matrix.end)) {
            return matrix.start;
        }
        else {
            return matrix.end;
        }
    };
    /**
     * @param {?} matrix
     * @param {?} overlap
     * @return {?}
     */
    NlsMathService.prototype.randomPoint = /**
     * @param {?} matrix
     * @param {?} overlap
     * @return {?}
     */
    function (matrix, overlap) {
        /** @type {?} */
        var x = {
            min: matrix.center.x - matrix.width * overlap,
            max: matrix.center.x + matrix.width * overlap
        };
        /** @type {?} */
        var y = {
            min: matrix.center.y - matrix.height * overlap,
            max: matrix.center.y + matrix.height * overlap
        };
        return {
            x: randomUniform(x.min, x.max)(),
            y: randomUniform(y.min, y.max)()
        };
    };
    /**
     * @param {?} width
     * @param {?} height
     * @return {?}
     */
    NlsMathService.prototype.centerOfArea = /**
     * @param {?} width
     * @param {?} height
     * @return {?}
     */
    function (width, height) {
        return {
            x: width * 0.5,
            y: height * 0.5
        };
    };
    /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    NlsMathService.prototype.centerOfPoints = /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    function (p1, p2) {
        return {
            x: (p1.x + p2.x) * 0.5,
            y: (p1.y + p2.y) * 0.5
        };
    };
    /**
     * @param {?} curve
     * @return {?}
     */
    NlsMathService.prototype.centerOfCurve = /**
     * @param {?} curve
     * @return {?}
     */
    function (curve) {
        /** @type {?} */
        var genMedian = this.medianPoint(curve);
        /** @type {?} */
        var p1 = genMedian.next().value;
        /** @type {?} */
        var p2 = genMedian.next().value;
        /** @type {?} */
        var radians = this.angleRadians(p1, p2);
        return Object.assign(this.centerOfPoints(p1, p2), { ascent: radians });
    };
    /**
     * @param {?} curve
     * @return {?}
     */
    NlsMathService.prototype.medianOfCurve = /**
     * @param {?} curve
     * @return {?}
     */
    function (curve) {
        /** @type {?} */
        var genMedian = this.medianPoint(curve);
        /** @type {?} */
        var p1 = genMedian.next().value;
        /** @type {?} */
        var p2 = genMedian.next().value;
        /** @type {?} */
        var p3 = genMedian.next().value;
        /** @type {?} */
        var radians = this.angleRadians(p2, p3);
        // const radians = Math.round(Math.random() * 10000) / 1000;
        // @todo if nodes are less than 5 error occures
        return Object.assign(p1, { ascent: radians });
    };
    /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    NlsMathService.prototype.angleRadians = /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    function (p1, p2) {
        return Math.atan2(p2.y - p1.y, p2.x - p1.x);
    };
    /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    NlsMathService.prototype.angleDegree = /**
     * @param {?} p1
     * @param {?} p2
     * @return {?}
     */
    function (p1, p2) {
        return this.angleRadians(p1, p2) * 180 / Math.PI;
    };
    /**
     * @param {?} list
     * @return {?}
     */
    NlsMathService.prototype.medianIndex = /**
     * @param {?} list
     * @return {?}
     */
    function (list) {
        return Math.floor(list.length * 0.5);
    };
    /**
     * @param {?} points
     * @return {?}
     */
    NlsMathService.prototype.medianPoint = /**
     * @param {?} points
     * @return {?}
     */
    function (points) {
        var index, list;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    list = points.slice();
                    _a.label = 1;
                case 1:
                    if (!list) return [3 /*break*/, 3];
                    index = this.medianIndex(points);
                    return [4 /*yield*/, list[index]];
                case 2:
                    _a.sent();
                    list.splice(index, 1);
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    /**
     * Generator for sine bounce
     *
     * @param {?=} amplitude default to 1 indicates the amplitude in positive as well
     * in negative range
     * @param {?=} decimals amount of decimal places
     * @param {?=} start 0 indicates to initiate with positive numbers, 1 indicates to
     * start with negative numbers first
     * @return {?}
     */
    NlsMathService.prototype.bounce = /**
     * Generator for sine bounce
     *
     * @param {?=} amplitude default to 1 indicates the amplitude in positive as well
     * in negative range
     * @param {?=} decimals amount of decimal places
     * @param {?=} start 0 indicates to initiate with positive numbers, 1 indicates to
     * start with negative numbers first
     * @return {?}
     */
    function (amplitude, decimals, start) {
        if (amplitude === void 0) { amplitude = 1; }
        if (decimals === void 0) { decimals = 1; }
        if (start === void 0) { start = 0; }
        var power, step, index, radians;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    power = Math.pow(10, decimals);
                    step = 2 / (power);
                    index = 0;
                    _a.label = 1;
                case 1:
                    radians = Math.PI * step * index + start;
                    return [4 /*yield*/, Math.round((Math.sin(radians) * amplitude) * power) / power];
                case 2:
                    _a.sent();
                    index++;
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    /**
     * @param {?=} startPositive
     * @return {?}
     */
    NlsMathService.prototype.flipSign = /**
     * @param {?=} startPositive
     * @return {?}
     */
    function (startPositive) {
        if (startPositive === void 0) { startPositive = true; }
        var sign;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    sign = startPositive ? 1 : -1;
                    _a.label = 1;
                case 1:
                    return [4 /*yield*/, sign = sign * (-1)];
                case 2:
                    _a.sent();
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    NlsMathService.decorators = [
        { type: Injectable },
    ];
    return NlsMathService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsGraphService = /** @class */ (function () {
    function NlsGraphService(math) {
        this.math = math;
    }
    /**
     * @return {?}
     */
    NlsGraphService.prototype.get = /**
     * @return {?}
     */
    function () {
        return this.graphs;
    };
    /**
     * @param {?} newGraphs
     * @return {?}
     */
    NlsGraphService.prototype.set = /**
     * @param {?} newGraphs
     * @return {?}
     */
    function (newGraphs) {
        this.graphs = newGraphs;
    };
    Object.defineProperty(NlsGraphService.prototype, "isAnimated", {
        get: /**
         * @return {?}
         */
        function () {
            return this.animation;
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @return {?}
     */
    NlsGraphService.prototype.startAnimation = /**
     * @return {?}
     */
    function () {
        this.animation = true;
    };
    /**
     * @return {?}
     */
    NlsGraphService.prototype.stopAnimation = /**
     * @return {?}
     */
    function () {
        this.animation = false;
    };
    /**
     * @param {?} start
     * @param {?} spacing
     * @return {?}
     */
    NlsGraphService.prototype.spreadOrthogonal = /**
     * @param {?} start
     * @param {?} spacing
     * @return {?}
     */
    function (start, spacing) {
        var sign, currentPoint, i, currentSpacing;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    sign = this.math.flipSign();
                    currentPoint = start;
                    i = 0;
                    _a.label = 1;
                case 1:
                    currentSpacing = sign.next().value * spacing * i;
                    currentPoint = this.shiftPoint(currentPoint, start.ascent, currentSpacing);
                    return [4 /*yield*/, currentPoint];
                case 2:
                    _a.sent();
                    i++;
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    /**
     * @param {?} point
     * @param {?} radians
     * @param {?} spacing
     * @return {?}
     */
    NlsGraphService.prototype.shiftPoint = /**
     * @param {?} point
     * @param {?} radians
     * @param {?} spacing
     * @return {?}
     */
    function (point, radians, spacing) {
        return {
            x: Math.sin(radians * Math.PI) * spacing + point.x,
            y: Math.cos(radians * Math.PI) * spacing + point.y
        };
    };
    NlsGraphService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    NlsGraphService.ctorParameters = function () { return [
        { type: NlsMathService }
    ]; };
    return NlsGraphService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/** @type {?} */
var RESIZING_TIMEOUT = 800;
var NlsGraphsComponent = /** @class */ (function () {
    function NlsGraphsComponent(canvasService, historyService, math, graphService) {
        this.canvasService = canvasService;
        this.historyService = historyService;
        this.math = math;
        this.graphService = graphService;
        this.svgChange = new EventEmitter();
        this.graphChange = new EventEmitter();
        this.genLoadedAllGraphs = this.countLoadedGraphs();
        this.resizingWindow = false;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    NlsGraphsComponent.prototype.onResize = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        var _this = this;
        clearTimeout(this.resizingWindow);
        this.resizingWindow = setTimeout(function () {
            _this.canvas = _this.adjustCanvas();
            _this.matrix = _this.calcMatrix();
            _this.updateGraphs();
        }, RESIZING_TIMEOUT);
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    NlsGraphsComponent.prototype.ngOnChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        this.canvas = this.adjustCanvas();
        this.matrix = this.calcMatrix();
        if (changes["config"]) {
            this.updateGraphs();
        }
        if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {
            this.restoreGraph();
        }
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.restoreGraph = /**
     * @return {?}
     */
    function () {
        this.graphs = this.restoredHistory.graphs;
        this.hash = this.restoredHistory.hash;
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.saveHistory = /**
     * @return {?}
     */
    function () {
        this.hash = this.historyService.hash(this.graphs);
        this.historyService.save(this.graphs, this.config);
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.saveGraph = /**
     * @return {?}
     */
    function () {
        this.graphService.set(this.graphs);
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.updateGraphs = /**
     * @return {?}
     */
    function () {
        var _this = this;
        /** @type {?} */
        var genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);
        /** @type {?} */
        var genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);
        console.log(this.matrix);
        /** @type {?} */
        var curveList = [
            {
                color: this.config.colors.primary,
                start: genShiftStart.next().value,
                end: genShiftEnd.next().value
            },
            {
                color: this.config.colors.secondary,
                start: genShiftEnd.next().value,
                end: genShiftStart.next().value
            }
        ];
        this.graphs = curveList.map(function (curve) {
            return __assign({}, _this.adjustGraph(curve), { spread: _this.config.spread, interval: _this.config.interval });
        });
        this.hash = this.historyService.hash(this.graphs);
        this.saveHistory();
        this.saveGraph();
    };
    /**
     * @param {?} curve
     * @return {?}
     */
    NlsGraphsComponent.prototype.adjustGraph = /**
     * @param {?} curve
     * @return {?}
     */
    function (curve) {
        return Object.assign(curve, {
            stroke: this.config.stroke,
            start: Object.assign(curve.start, {
                direction: this.genVectorPoint(curve.start.point, curve.start.vector)
            }),
            end: Object.assign(curve.end, {
                direction: this.genVectorPoint(curve.end.point, curve.end.vector)
            }),
            nodes: this.genRandomPoints(this.config.nodes)
        });
    };
    /**
     * @param {?} num
     * @return {?}
     */
    NlsGraphsComponent.prototype.genRandomPoints = /**
     * @param {?} num
     * @return {?}
     */
    function (num) {
        /** @type {?} */
        var generatedPoints = [];
        for (var i = 0; i < this.config.nodes; i++) {
            generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));
        }
        return generatedPoints;
    };
    /**
     * @param {?} x
     * @return {?}
     */
    NlsGraphsComponent.prototype.flipflop = /**
     * @param {?} x
     * @return {?}
     */
    function (x) {
        return (x === 'start') ? 'end' : 'start';
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.adjustCanvas = /**
     * @return {?}
     */
    function () {
        this.canvasService.set(this.canvas);
        this.canvasService.adjustToWindow();
        return this.svgElementRef.nativeElement;
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.calcMatrix = /**
     * @return {?}
     */
    function () {
        /** @type {?} */
        var canvasWidth = this.canvas.getBoundingClientRect().width;
        /** @type {?} */
        var canvasHeight = this.canvas.getBoundingClientRect().height;
        /** @type {?} */
        var totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);
        return {
            start: {
                x: 0,
                y: canvasHeight - this.config.vectors.spacing - this.config.margin.y
            },
            end: {
                x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,
                y: 0
            },
            width: canvasWidth,
            height: canvasHeight,
            center: totalCenter
        };
    };
    /**
     * @param {?} point
     * @param {?} vector
     * @return {?}
     */
    NlsGraphsComponent.prototype.genVectorPoint = /**
     * @param {?} point
     * @param {?} vector
     * @return {?}
     */
    function (point, vector) {
        /** @type {?} */
        var range = this.math.Δ(this.matrix.start, this.matrix.end) * this.config.vectors.range;
        return {
            x: range * Math.sin(Math.PI * vector) + point.x,
            y: range * Math.cos(Math.PI * vector) + point.y
        };
    };
    /**
     * @param {?} point
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    NlsGraphsComponent.prototype.shiftPoint = /**
     * @param {?} point
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    function (point, vector, startPositive) {
        if (startPositive === void 0) { startPositive = true; }
        var genShiftX, genShiftY;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
                    genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
                    _a.label = 1;
                case 1:
                    return [4 /*yield*/, {
                            point: {
                                x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,
                                y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,
                            },
                            vector: vector
                        }];
                case 2:
                    _a.sent();
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    /**
     * @param {?} space
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    NlsGraphsComponent.prototype.shiftNumber = /**
     * @param {?} space
     * @param {?} vector
     * @param {?=} startPositive
     * @return {?}
     */
    function (space, vector, startPositive) {
        if (startPositive === void 0) { startPositive = true; }
        var current, index, sign;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    current = 0;
                    index = 0;
                    sign = this.math.flipSign(startPositive);
                    _a.label = 1;
                case 1:
                    return [4 /*yield*/, current = sign.next().value * index * space + current];
                case 2:
                    _a.sent();
                    index++;
                    return [3 /*break*/, 1];
                case 3: return [2 /*return*/];
            }
        });
    };
    /**
     * @param {?} guillocheElement
     * @return {?}
     */
    NlsGraphsComponent.prototype.prepareGuillocheExport = /**
     * @param {?} guillocheElement
     * @return {?}
     */
    function (guillocheElement) {
        if (this.genLoadedAllGraphs.next().value) {
            this.svgChange.emit(this.svgElementRef);
        }
    };
    /**
     * @return {?}
     */
    NlsGraphsComponent.prototype.countLoadedGraphs = /**
     * @return {?}
     */
    function () {
        var cycles;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    cycles = 1;
                    _a.label = 1;
                case 1:
                    if (!(cycles < this.graphs.length)) return [3 /*break*/, 3];
                    return [4 /*yield*/, false];
                case 2:
                    _a.sent();
                    cycles++;
                    return [3 /*break*/, 5];
                case 3: return [4 /*yield*/, true];
                case 4:
                    _a.sent();
                    cycles = 1;
                    _a.label = 5;
                case 5: return [3 /*break*/, 1];
                case 6: return [2 /*return*/];
            }
        });
    };
    NlsGraphsComponent.decorators = [
        { type: Component, args: [{
                    selector: 'nls-graphs',
                    template: "<svg #svg width=\"100%\" height=\"100%\" xmlns=\"http://www.w3.org/2000/svg\"\nversion=\"1.1\" shape-rendering=\"geometricPrecision\">\n  <g nlsGuilloche *ngFor=\"let graph of graphs\" [graph]=\"graph\" [animation]=\"animation\"></g>\n</svg>\n",
                    styles: [":host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}"]
                },] },
    ];
    /** @nocollapse */
    NlsGraphsComponent.ctorParameters = function () { return [
        { type: NlsCanvasService },
        { type: NlsHistoryService },
        { type: NlsMathService },
        { type: NlsGraphService }
    ]; };
    NlsGraphsComponent.propDecorators = {
        config: [{ type: Input }],
        restoredHistory: [{ type: Input }],
        animation: [{ type: Input }],
        svgChange: [{ type: Output }],
        graphChange: [{ type: Output }],
        svgElementRef: [{ type: ViewChild, args: ['svg',] }],
        onResize: [{ type: HostListener, args: ['window:resize', ['$event'],] }]
    };
    return NlsGraphsComponent;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsGuillocheDirective = /** @class */ (function () {
    function NlsGuillocheDirective(canvasService, el, math, graphService) {
        this.canvasService = canvasService;
        this.el = el;
        this.math = math;
        this.graphService = graphService;
    }
    /**
     * @return {?}
     */
    NlsGuillocheDirective.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        this.group.selectAll('*').remove();
    };
    /**
     * @param {?} changes
     * @return {?}
     */
    NlsGuillocheDirective.prototype.ngOnChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        var _this = this;
        this.group = select(this.el.nativeElement);
        this.canvas = select(this.canvasService.get);
        // @todo modify graph here instead of in graphs.component.ts
        this.initialNodes = this.graph.nodes.slice();
        this.initialCurve = __spread([
            this.graph.start.point,
            this.graph.start.direction
        ], this.graph.nodes.slice(), [
            this.graph.end.direction,
            this.graph.end.point
        ]);
        this.medianPoint = this.math.medianOfCurve(this.initialCurve);
        this.medianIndex = this.math.medianIndex(this.initialCurve);
        if (this.animation) {
            this.graph.nodes = this.graph.nodes.slice().map(function (node, i) {
                return {
                    x: node.x,
                    y: node.y,
                    // ascent: Math.round(Math.random() * 100) / 100
                    ascent: _this.medianPoint.ascent + i * 0.5
                };
            });
            this.bounces = this.initialNodes.map(function (node) {
                /** @type {?} */
                var bounceAmplitude = Math.round(Math.random() * 150);
                return _this.math.bounce(bounceAmplitude, 3);
            });
            /** @type {?} */
            var i_1 = 0;
            this.animationInterval = setInterval(function () {
                _this.animateGraph(i_1++ % 1000 / 10000);
            }, this.graph.interval);
        }
        else {
            if (this.animationInterval) {
                this.bounce = null;
                clearInterval(this.animationInterval);
            }
        }
        this.group.selectAll('*').remove();
        this.pathElements = [];
        /** @type {?} */
        var graphs = this.spreadLines(__spread([
            this.graph.start.point,
            this.graph.start.direction
        ], this.graph.nodes, [
            this.graph.end.direction,
            this.graph.end.point,
        ])).forEach(function (points, index) { return _this.drawGraph(points); });
    };
    /**
     * @param {?} x
     * @return {?}
     */
    NlsGuillocheDirective.prototype.animateGraph = /**
     * @param {?} x
     * @return {?}
     */
    function (x) {
        var _this = this;
        /** @type {?} */
        var graphs = this.spreadLines(__spread([
            this.graph.start.point,
            this.graph.start.direction
        ], this.graph.nodes.map(function (point, i) {
            /** @type {?} */
            var ascent = point.ascent * Math.sin(Math.PI * x);
            return _this.graphService.shiftPoint(point, ascent, _this.bounces[i].next().value);
        }), [
            this.graph.end.direction,
            this.graph.end.point,
        ]));
        graphs.forEach(function (points, i) { return _this.updateGraph(points, i); });
    };
    /**
     * @param {?} points
     * @return {?}
     */
    NlsGuillocheDirective.prototype.spreadLines = /**
     * @param {?} points
     * @return {?}
     */
    function (points) {
        var _this = this;
        /** @type {?} */
        var shiftedMedians = [];
        /** @type {?} */
        var genshiftedMedians = this.graphService.spreadOrthogonal(this.medianPoint, this.graph.spread.spacing);
        for (var i = 0; i < this.graph.spread.amount; i++) {
            shiftedMedians.push(genshiftedMedians.next().value);
        }
        return shiftedMedians.map(function (median) {
            /** @type {?} */
            var shiftedPoints = points.slice();
            shiftedPoints.splice(_this.medianIndex, 1, median);
            return shiftedPoints;
        });
    };
    /**
     * @param {?} points
     * @param {?} index
     * @return {?}
     */
    NlsGuillocheDirective.prototype.updateGraph = /**
     * @param {?} points
     * @param {?} index
     * @return {?}
     */
    function (points, index) {
        this.pathElements[index]
            .attr('d', line()
            .x(function (p) { return p.x; })
            .y(function (p) { return p.y; })
            .curve(curveBasis)(points));
    };
    /**
     * @param {?} points
     * @return {?}
     */
    NlsGuillocheDirective.prototype.drawGraph = /**
     * @param {?} points
     * @return {?}
     */
    function (points) {
        this.group
            .attr('stroke', this.graph.color)
            .attr('stroke-width', this.graph.stroke)
            .attr('fill', 'none');
        this.pathElements.push(this.group.append('path')
            .attr('d', line()
            .x(function (p) { return p.x; })
            .y(function (p) { return p.y; })
            .curve(curveBasis)(points)));
    };
    /**
     * @param {?} points
     * @return {?}
     */
    NlsGuillocheDirective.prototype.debugGraph = /**
     * @param {?} points
     * @return {?}
     */
    function (points) {
        var _this = this;
        points.forEach(function (point, index) {
            /** @type {?} */
            var circle = _this.group.append('g');
            circle.append('circle')
                .attr('cx', point.x)
                .attr('cy', point.y)
                .attr('r', 3)
                .attr('fill-opacity', 0.6)
                .attr('fill', _this.graph.color);
            circle.append('text')
                .attr('x', point.x)
                .attr('y', point.y)
                .attr('dx', 8)
                .attr('dy', 15)
                .attr('fill', _this.graph.color)
                .text(index);
        });
    };
    NlsGuillocheDirective.decorators = [
        { type: Directive, args: [{
                    selector: '[nlsGuilloche]'
                },] },
    ];
    /** @nocollapse */
    NlsGuillocheDirective.ctorParameters = function () { return [
        { type: NlsCanvasService },
        { type: ElementRef },
        { type: NlsMathService },
        { type: NlsGraphService }
    ]; };
    NlsGuillocheDirective.propDecorators = {
        graph: [{ type: Input }],
        animation: [{ type: Input }]
    };
    return NlsGuillocheDirective;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsAnimationService = /** @class */ (function () {
    // public genAnimation: any;
    // private timer: Observable<number>;
    // private subscribtion: any;
    function NlsAnimationService(math, historyService) {
        this.math = math;
        this.historyService = historyService;
    }
    /**
     * @param {?} initialGraph
     * @return {?}
     */
    NlsAnimationService.prototype.animate = /**
     * @param {?} initialGraph
     * @return {?}
     */
    function (initialGraph) {
        /** @type {?} */
        var newGraph = Object.assign({}, initialGraph);
        /** @type {?} */
        var indexMiddle = Math.floor(newGraph.nodes.length * 0.5);
        /** @type {?} */
        var pointMiddle = newGraph.nodes[indexMiddle];
        newGraph.nodes.splice(indexMiddle, 1, {
            x: pointMiddle.x - 2,
            y: pointMiddle.y + 2,
        });
        return newGraph;
        //   });
    };
    NlsAnimationService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    NlsAnimationService.ctorParameters = function () { return [
        { type: NlsMathService },
        { type: NlsHistoryService }
    ]; };
    return NlsAnimationService;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var NlsGuillocheModule = /** @class */ (function () {
    function NlsGuillocheModule() {
    }
    NlsGuillocheModule.decorators = [
        { type: NgModule, args: [{
                    imports: [
                        BrowserModule
                    ],
                    declarations: [
                        NlsGraphsComponent,
                        NlsGuillocheDirective
                    ],
                    providers: [
                        NlsHistoryService,
                        NlsCanvasService,
                        NlsMathService,
                        NlsGraphService,
                    ],
                    exports: [
                        NlsGraphsComponent,
                        NlsGuillocheDirective
                    ]
                },] },
    ];
    return NlsGuillocheModule;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */

export { NlsGraphsComponent, NlsGuillocheDirective, NlsAnimationService, NlsCanvasService, NlsGraphService, NlsHistoryService, NlsMathService, NlsGuillocheModule };

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"nls-guilloche.js.map","sources":["ng://nls-guilloche/nls/services/canvas.service.ts","ng://nls-guilloche/nls/services/history.service.ts","ng://nls-guilloche/nls/services/math.service.ts","ng://nls-guilloche/nls/services/graph.service.ts","ng://nls-guilloche/nls/components/graphs.component.ts","ng://nls-guilloche/nls/directives/guilloche.directive.ts","ng://nls-guilloche/nls/services/animation.service.ts","ng://nls-guilloche/nls/nls-guilloche.module.ts"],"sourcesContent":["/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\n@Injectable()\nexport class NlsCanvasService {\n  private renderer: Renderer2;\n\n  public canvas: any;\n\n  constructor(\n    private rendererFactory: RendererFactory2\n  ) {\n    this.renderer = rendererFactory.createRenderer(null, null);\n  }\n\n  public get get() {\n    return this.canvas;\n  }\n\n  public set(el) {\n    this.canvas = el;\n  }\n\n  public adjustToWindow() {\n    if (this.canvas) {\n      this.renderer.setStyle(\n        this.canvas,\n        'width',\n        this.canvas.innerWidth\n      );\n      this.renderer.setStyle(\n        this.canvas,\n        'height',\n        this.canvas.innerHeight\n      );\n    }\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Optional, ViewChild } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\nimport { Graph } from '../models/graph.model';\n\n@Injectable()\nexport class NlsHistoryService {\n\n  public history: any[];\n\n  constructor() {\n    this.history = [];\n  }\n\n  public save(graphs: Graph[], config) {\n    this.history.push({\n      date: new Date(),\n      graphs: graphs,\n      config: config,\n      hash: this.hash(graphs)\n    });\n  }\n\n  public hash(graphs) {\n    return btoa(JSON.stringify(graphs));\n  }\n\n  public list() {\n    return this.history;\n  }\n}\n\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable } from '@angular/core';\nimport * as Selection from 'd3-selection';\nimport * as Random from 'd3-random';\n\nimport { Point } from './../models/point.model';\nimport { Graph } from './../models/graph.model';\n\n@Injectable()\nexport class NlsMathService {\n\n  /**\n   * Calculate distance between to points with coordinates.\n   * @param a\n   * @param b\n   */\n  public Î(a: Point, b: Point) {\n    return Math.pow(Math.pow(a.x - b.x, 2) + Math.pow(a.y - b.y, 2), 0.5);\n  }\n\n  public getClosestCenter(point: Point, matrix: any) {\n    if (this.Î(point, matrix.start) < this.Î(point, matrix.end)) {\n      return matrix.start;\n    } else {\n      return matrix.end;\n    }\n  }\n\n  public getFarestCenter(point: Point, matrix: any) {\n    if (this.Î(point, matrix.start) > this.Î(point, matrix.end)) {\n      return matrix.start;\n    } else {\n      return matrix.end;\n    }\n  }\n\n  public randomPoint(matrix: any, overlap: number) {\n    const x = {\n      min: matrix.center.x - matrix.width * overlap,\n      max: matrix.center.x + matrix.width * overlap\n    };\n    const y = {\n      min: matrix.center.y - matrix.height * overlap,\n      max: matrix.center.y + matrix.height * overlap\n    };\n\n    return {\n      x: Random.randomUniform(x.min, x.max)(),\n      y: Random.randomUniform(y.min, y.max)()\n    };\n  }\n\n  public centerOfArea(width, height): Point {\n    return {\n      x: width * 0.5,\n      y: height * 0.5\n    };\n  }\n\n  public centerOfPoints(p1: Point, p2: Point) {\n    return {\n      x: (p1.x + p2.x) * 0.5,\n      y: (p1.y + p2.y) * 0.5\n    };\n  }\n\n  public centerOfCurve(curve: Point[]) {\n    const genMedian = this.medianPoint(curve);\n    const p1 = genMedian.next().value;\n    const p2 = genMedian.next().value;\n    const radians = this.angleRadians(p1, p2);\n\n    return Object.assign(this.centerOfPoints(p1, p2), { ascent: radians });\n  }\n\n  public medianOfCurve(curve: Point[]) {\n    const genMedian = this.medianPoint(curve);\n    const p1 = genMedian.next().value;\n    const p2 = genMedian.next().value;\n    const p3 = genMedian.next().value;\n    const radians = this.angleRadians(p2, p3);\n    // const radians = Math.round(Math.random() * 10000) / 1000;\n    // @todo if nodes are less than 5 error occures\n    return Object.assign(p1, { ascent: radians });\n  }\n\n  public angleRadians(p1: Point, p2: Point) {\n    return Math.atan2(p2.y - p1.y, p2.x - p1.x);\n  }\n\n  public angleDegree(p1: Point, p2: Point) {\n    return this.angleRadians(p1, p2) * 180 / Math.PI;\n  }\n\n  public medianIndex(list: any): number {\n    return Math.floor(list.length * 0.5);\n  }\n\n  public *medianPoint(points: Point[]) {\n    let index: number;\n    const list: Point[] = points.slice();\n\n    while (list) {\n      index = this.medianIndex(points);\n      yield list[index];\n\n      list.splice(index, 1);\n    }\n  }\n\n  /**\n   * Generator for sine bounce\n   *\n   * @param start 0 indicates to initiate with positive numbers, 1 indicates to\n   * start with negative numbers first\n   * @param amplitude default to 1 indicates the amplitude in positive as well\n   * in negative range\n   * @param decimals amount of decimal places\n   */\n\n  public *bounce(\n    amplitude: number = 1,\n    decimals: number = 1,\n    start: number = 0\n  ) {\n    const power = Math.pow(10, decimals);\n    const step = 2 / (power);\n    let index = 0;\n\n    while (true) {\n      const radians = Math.PI * step * index + start;\n      yield Math.round((Math.sin(radians) * amplitude) * power) / power;\n\n      index++;\n    }\n  }\n\n  public *flipSign(startPositive: boolean = true) {\n    let sign = startPositive ? 1 : -1;\n\n    while (true) {\n      yield sign = sign * (-1);\n    }\n  }\n}\n","import { Validators } from '@angular/forms';\n/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Renderer2, RendererFactory2 } from '@angular/core';\nimport * as Selection from 'd3-selection';\n\nimport { NlsMathService } from './math.service';\nimport { Graph } from './../models/graph.model';\nimport { Point } from './../models/point.model';\n\n@Injectable()\nexport class NlsGraphService {\n  private graphs: Graph[];\n  private animation: boolean | null;\n\n  constructor(\n    private math: NlsMathService\n  ) {}\n\n  public get() {\n    return this.graphs;\n  }\n\n  public set(newGraphs: Graph[]) {\n    this.graphs = newGraphs;\n  }\n\n  public get isAnimated() {\n    return this.animation;\n  }\n\n  public startAnimation() {\n    this.animation = true;\n  }\n\n  public stopAnimation() {\n    this.animation = false;\n  }\n\n  public *spreadOrthogonal(start: Point, spacing: number) {\n    const sign = this.math.flipSign();\n    let currentPoint = start;\n    let i = 0;\n\n    while (true) {\n      const currentSpacing = sign.next().value * spacing * i;\n      currentPoint = this.shiftPoint(currentPoint, start.ascent, currentSpacing);\n\n      yield currentPoint;\n\n      i++;\n    }\n  }\n\n  public shiftPoint(point: Point, radians: number, spacing: number): Point {\n    return {\n      x: Math.sin(radians * Math.PI) * spacing + point.x,\n      y: Math.cos(radians * Math.PI) * spacing + point.y\n    };\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { ViewChild, Component, Input, Output, SimpleChanges, OnChanges, EventEmitter, HostListener } from '@angular/core';\nimport { Observable, interval } from 'rxjs';\nimport * as Selection from 'd3-selection';\nimport * as Shape from 'd3-shape';\nimport * as Random from 'd3-random';\nimport * as Drag from 'd3-drag';\n\nimport { Graph } from './../models/graph.model';\nimport { Config } from './../models/config.model';\nimport { Point } from './../models/point.model';\nimport { NlsCanvasService } from './../services/canvas.service';\nimport { NlsHistoryService } from './../services/history.service';\nimport { NlsMathService } from './../services/math.service';\nimport { NlsGuillocheDirective } from './../directives/guilloche.directive';\nimport { NlsGraphService } from './../services/graph.service';\n\nconst RESIZING_TIMEOUT = 800;\n\n@Component({\n  selector: 'nls-graphs',\n  template: `<svg #svg width=\"100%\" height=\"100%\" xmlns=\"http://www.w3.org/2000/svg\"\nversion=\"1.1\" shape-rendering=\"geometricPrecision\">\n  <g nlsGuilloche *ngFor=\"let graph of graphs\" [graph]=\"graph\" [animation]=\"animation\"></g>\n</svg>\n`,\n  styles: [`:host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}`]\n})\nexport class NlsGraphsComponent implements OnChanges {\n\n  public canvas: any | null;\n  public matrix: any | null;\n  public graphs: Graph[];\n  public windowHeight: number | null;\n  public windowWidth: number | null;\n\n  private genShiftPoint: any | null;\n  private genLoadedAllGraphs: any | null;\n  private hash: string;\n  private resizingWindow: any;\n\n  @Input() config: Config;\n  @Input() restoredHistory: any;\n  @Input() animation: boolean;\n  @Output() svgChange = new EventEmitter();\n  @Output() graphChange = new EventEmitter();\n  @ViewChild('svg') svgElementRef;\n\n  @HostListener('window:resize', ['$event'])\n  onResize(event) {\n    clearTimeout(this.resizingWindow);\n\n    this.resizingWindow = setTimeout(() => {\n      this.canvas = this.adjustCanvas();\n      this.matrix = this.calcMatrix();\n      this.updateGraphs();\n    }, RESIZING_TIMEOUT);\n  }\n\n  constructor(\n    private canvasService: NlsCanvasService,\n    private historyService: NlsHistoryService,\n    private math: NlsMathService,\n    private graphService: NlsGraphService\n  ) {\n    this.genLoadedAllGraphs = this.countLoadedGraphs();\n    this.resizingWindow = false;\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.canvas = this.adjustCanvas();\n    this.matrix = this.calcMatrix();\n\n    if (changes.config) {\n      this.updateGraphs();\n    }\n\n    if (this.restoredHistory && this.restoredHistory.hash !== this.hash) {\n      this.restoreGraph();\n    }\n  }\n\n  private restoreGraph() {\n    this.graphs = this.restoredHistory.graphs;\n    this.hash = this.restoredHistory.hash;\n  }\n\n  private saveHistory() {\n    this.hash = this.historyService.hash(this.graphs);\n    this.historyService.save(this.graphs, this.config);\n  }\n\n  private saveGraph() {\n    this.graphService.set(this.graphs);\n  }\n\n  private updateGraphs(): void {\n    const genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);\n    const genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);\n\n    console.log(this.matrix);\n\n    const curveList = [\n      {\n        color: this.config.colors.primary,\n        start: genShiftStart.next().value,\n        end: genShiftEnd.next().value\n        // start: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // end: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      },\n      {\n        color: this.config.colors.secondary,\n        start: genShiftEnd.next().value,\n        end: genShiftStart.next().value\n        // end: {\n        //   point: this.matrix.start,\n        //   vector: this.config.vectors.start\n        // },\n        // start: {\n        //   point: this.matrix.end,\n        //   vector: this.config.vectors.end\n        // }\n      }\n    ];\n\n    this.graphs = curveList.map(curve => {\n      return {\n        ...this.adjustGraph(curve),\n        spread: this.config.spread,\n        interval: this.config.interval\n      };\n    });\n    this.hash = this.historyService.hash(this.graphs);\n    this.saveHistory();\n    this.saveGraph();\n  }\n\n  private adjustGraph(curve) {\n    return Object.assign(curve, {\n      stroke: this.config.stroke,\n      start: Object.assign(curve.start, {\n        direction: this.genVectorPoint(curve.start.point, curve.start.vector)\n      }),\n      end: Object.assign(curve.end, {\n        direction: this.genVectorPoint(curve.end.point, curve.end.vector)\n      }),\n      nodes: this.genRandomPoints(this.config.nodes)\n    });\n  }\n\n  private genRandomPoints(num: number) {\n    const generatedPoints = [];\n\n    for (let i = 0; i < this.config.nodes; i++) {\n      generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));\n    }\n\n    return generatedPoints;\n  }\n\n  private flipflop(x: string) {\n    return (x === 'start') ? 'end' : 'start';\n  }\n\n  private adjustCanvas(): void {\n    this.canvasService.set(this.canvas);\n    this.canvasService.adjustToWindow();\n\n    return this.svgElementRef.nativeElement;\n  }\n\n  private calcMatrix() {\n    const canvasWidth = this.canvas.getBoundingClientRect().width;\n    const canvasHeight = this.canvas.getBoundingClientRect().height;\n    const totalArea = Math.abs(canvasWidth * canvasHeight);\n    const totalCenter = this.math.centerOfArea(canvasWidth, canvasHeight);\n\n    return {\n      start: {\n        x: 0,\n        y: canvasHeight - this.config.vectors.spacing - this.config.margin.y\n      },\n      end: {\n        x: canvasWidth - this.config.vectors.spacing - this.config.margin.x,\n        y: 0\n      },\n      width: canvasWidth,\n      height: canvasHeight,\n      center: totalCenter\n    };\n  }\n\n  private genVectorPoint(point: Point, vector: number) {\n    const range = this.math.Î(this.matrix.start, this.matrix.end) * this.config.vectors.range;\n\n    return {\n      x: range * Math.sin(Math.PI * vector) + point.x,\n      y: range * Math.cos(Math.PI * vector) + point.y\n    };\n  }\n\n  private *shiftPoint(point: Point, vector: number, startPositive: boolean = true) {\n    const genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n    const genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);\n\n    while (true) {\n      yield {\n        point: {\n          x: Math.cos(Math.PI * vector) * genShiftX.next().value + point.x,\n          y: Math.sin(Math.PI * vector) * genShiftY.next().value + point.y,\n        },\n        vector: vector\n      };\n    }\n  }\n\n  private *shiftNumber(space: number, vector: number, startPositive: boolean = true) {\n    let current = 0;\n    let index = 0;\n    const sign = this.math.flipSign(startPositive);\n\n    while (true) {\n      yield current = sign.next().value * index * space + current;\n      index++;\n    }\n  }\n\n  public prepareGuillocheExport(guillocheElement) {\n    if (this.genLoadedAllGraphs.next().value) {\n      this.svgChange.emit(this.svgElementRef);\n    }\n  }\n\n  private *countLoadedGraphs() {\n    let cycles = 1;\n\n    while (true) {\n      if (cycles < this.graphs.length) {\n        yield false;\n        cycles++;\n      } else {\n        yield true;\n        cycles = 1;\n      }\n    }\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { ElementRef, HostListener, Input, Directive, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';\nimport * as Selection from 'd3-selection';\nimport * as Shape from 'd3-shape';\nimport * as Random from 'd3-random';\nimport * as Drag from 'd3-drag';\nimport * as Ease from 'd3-ease';\nimport * as Timer from 'd3-timer';\n\nimport { Graph } from './../models/graph.model';\nimport { Point } from './../models/point.model';\nimport { NlsCanvasService } from './../services/canvas.service';\nimport { NlsMathService } from './../services/math.service';\nimport { NlsGraphService } from '../services/graph.service';\n\n@Directive({\n  selector: '[nlsGuilloche]'\n})\nexport class NlsGuillocheDirective implements OnChanges, OnDestroy {\n\n  private canvas: any;\n  private group: any;\n  private bounce: any | null;\n  private bounces: any | null;\n  private initialNodes: any;\n  private initialCurve: any;\n  private animationInterval: any;\n  private medianPoint: Point;\n  private medianIndex: number;\n  private pathElements: any;\n\n  @Input() graph: Graph;\n  @Input() animation: boolean;\n\n  constructor(\n    private canvasService: NlsCanvasService,\n    private el: ElementRef,\n    private math: NlsMathService,\n    private graphService: NlsGraphService\n  ) {\n  }\n\n  ngOnDestroy() {\n    this.group.selectAll('*').remove();\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    this.group = Selection.select(this.el.nativeElement);\n    this.canvas = Selection.select(this.canvasService.get);\n    // @todo modify graph here instead of in graphs.component.ts\n    this.initialNodes = this.graph.nodes.slice();\n    this.initialCurve = [\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes.slice(),\n      this.graph.end.direction,\n      this.graph.end.point\n    ];\n    this.medianPoint = this.math.medianOfCurve(this.initialCurve);\n    this.medianIndex = this.math.medianIndex(this.initialCurve);\n\n    if (this.animation) {\n      this.graph.nodes = this.graph.nodes.slice().map((node, i) => {\n        return {\n          x: node.x,\n          y: node.y,\n          // ascent: Math.round(Math.random() * 100) / 100\n          ascent: this.medianPoint.ascent + i * 0.5\n        };\n      });\n      this.bounces = this.initialNodes.map(node => {\n        const bounceAmplitude = Math.round(Math.random() * 150);\n        return this.math.bounce(bounceAmplitude, 3);\n      });\n      let i = 0;\n      this.animationInterval = setInterval(() => {\n        this.animateGraph(i++ % 1000 / 10000);\n      }, this.graph.interval);\n    } else {\n      if (this.animationInterval) {\n        this.bounce = null;\n        clearInterval(this.animationInterval);\n      }\n    }\n\n    this.group.selectAll('*').remove();\n    this.pathElements = [];\n\n    const graphs = this.spreadLines([\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes,\n      this.graph.end.direction,\n      this.graph.end.point,\n    ]).forEach((points, index) => this.drawGraph(points));\n  }\n\n  private animateGraph(x) {\n    const graphs = this.spreadLines([\n      this.graph.start.point,\n      this.graph.start.direction,\n      ...this.graph.nodes.map((point, i) => {\n        const ascent = point.ascent * Math.sin(Math.PI * x);\n        return this.graphService.shiftPoint(point, ascent, this.bounces[i].next().value);\n      }),\n      this.graph.end.direction,\n      this.graph.end.point,\n    ]);\n\n    graphs.forEach((points, i) => this.updateGraph(points, i));\n  }\n\n  private spreadLines(points: Point[]) {\n    const shiftedMedians = [];\n    const genshiftedMedians = this.graphService.spreadOrthogonal(this.medianPoint, this.graph.spread.spacing);\n\n    for (let i = 0; i < this.graph.spread.amount; i++) {\n      shiftedMedians.push(genshiftedMedians.next().value);\n    }\n\n    return shiftedMedians.map(median => {\n      const shiftedPoints = points.slice();\n      shiftedPoints.splice(this.medianIndex, 1, median);\n      return shiftedPoints;\n    });\n  }\n\n  private updateGraph(points: Point[], index: number): void {\n    this.pathElements[index]\n      .attr('d', Shape.line()\n        .x(p => p.x)\n        .y(p => p.y)\n        .curve(Shape.curveBasis)(points));\n  }\n\n  private drawGraph(points: Point[]): void {\n    this.group\n      .attr('stroke', this.graph.color)\n      .attr('stroke-width', this.graph.stroke)\n      .attr('fill', 'none');\n\n    this.pathElements.push(\n      this.group.append('path')\n        .attr('d', Shape.line()\n          .x(p => p.x)\n          .y(p => p.y)\n          .curve(Shape.curveBasis)(points)));\n  }\n\n  private debugGraph(points: Point[]) {\n    points.forEach((point, index) => {\n      const circle = this.group.append('g');\n\n      circle.append('circle')\n        .attr('cx', point.x)\n        .attr('cy', point.y)\n        .attr('r', 3)\n        .attr('fill-opacity', 0.6)\n        .attr('fill', this.graph.color);\n\n      circle.append('text')\n        .attr('x', point.x)\n        .attr('y', point.y)\n        .attr('dx', 8)\n        .attr('dy', 15)\n        .attr('fill', this.graph.color)\n        .text(index);\n    });\n  }\n}\n","/**\n * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>\n * This program is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License as published by the Free\n * Software Foundation; version 2.\n *\n * This program is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\n * more details.\n *\n * You should have received a copy of the GNU General Public License along with\n * this program; if not, write to the Free Software Foundation, Inc., 51\n * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\nimport { Inject, Injectable, Optional, ViewChild } from '@angular/core';\nimport { interval, Observable } from 'rxjs';\nimport * as Selection from 'd3-selection';\n\nimport { Graph } from '../models/graph.model';\nimport { NlsMathService } from './math.service';\nimport { NlsHistoryService } from './history.service';\n\n@Injectable()\nexport class NlsAnimationService {\n\n  public graphs: Graph[];\n  public speed: number;\n  public range: number;\n  // public genAnimation: any;\n  // private timer: Observable<number>;\n  // private subscribtion: any;\n\n  constructor(\n    private math: NlsMathService,\n    private historyService: NlsHistoryService,\n  ) {\n  }\n\n  // public animate(initialGraphs: Graph[]) {\n  public animate(initialGraph: Graph) {\n    // const newGraphs = initialGraphs.slice();\n\n    // return newGraphs.map(graph => {\n\n      const newGraph = Object.assign({}, initialGraph);\n      const indexMiddle = Math.floor(newGraph.nodes.length * 0.5);\n      const pointMiddle = newGraph.nodes[indexMiddle];\n\n      newGraph.nodes.splice(indexMiddle, 1, {\n        x: pointMiddle.x - 2,\n        y: pointMiddle.y + 2,\n      });\n\n      return newGraph;\n  //   });\n  }\n}\n\n","import { BrowserModule } from '@angular/platform-browser';\nimport { NgModule } from '@angular/core';\n\nimport { NlsGraphsComponent } from './components/graphs.component';\nimport { NlsGuillocheDirective } from './directives/guilloche.directive';\nimport { NlsHistoryService } from './services/history.service';\nimport { NlsCanvasService } from './services/canvas.service';\nimport { NlsMathService } from './services/math.service';\nimport { NlsGraphService } from './services/graph.service';\n\n@NgModule({\n  imports: [\n    BrowserModule\n  ],\n  declarations: [\n    NlsGraphsComponent,\n    NlsGuillocheDirective\n  ],\n  providers: [\n    NlsHistoryService,\n    NlsCanvasService,\n    NlsMathService,\n    NlsGraphService,\n  ],\n  exports: [\n    NlsGraphsComponent,\n    NlsGuillocheDirective\n  ]\n})\nexport class NlsGuillocheModule {}\n"],"names":["Random.randomUniform","Selection.select","Shape.line","Shape.curveBasis"],"mappings":"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"}