/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * Copyright (C) 2018 Michael Czechowski <mail@dailysh.it>
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 51
 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
import { ElementRef, Input, Directive } from '@angular/core';
import * as Selection from 'd3-selection';
import * as Shape from 'd3-shape';
import { NlsCanvasService } from './../services/canvas.service';
import { NlsMathService } from './../services/math.service';
import { NlsGraphService } from '../services/graph.service';
export class NlsGuillocheDirective {
    /**
     * @param {?} canvasService
     * @param {?} el
     * @param {?} math
     * @param {?} graphService
     */
    constructor(canvasService, el, math, graphService) {
        this.canvasService = canvasService;
        this.el = el;
        this.math = math;
        this.graphService = graphService;
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.group.selectAll('*').remove();
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        this.group = Selection.select(this.el.nativeElement);
        this.canvas = Selection.select(this.canvasService.get);
        // @todo modify graph here instead of in graphs.component.ts
        this.initialNodes = this.graph.nodes.slice();
        this.initialCurve = [
            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((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(node => {
                /** @type {?} */
                const bounceAmplitude = Math.round(Math.random() * 150);
                return this.math.bounce(bounceAmplitude, 3);
            });
            /** @type {?} */
            let i = 0;
            this.animationInterval = setInterval(() => {
                this.animateGraph(i++ % 1000 / 10000);
            }, this.graph.interval);
        }
        else {
            if (this.animationInterval) {
                this.bounce = null;
                clearInterval(this.animationInterval);
            }
        }
        this.group.selectAll('*').remove();
        this.pathElements = [];
        /** @type {?} */
        const graphs = this.spreadLines([
            this.graph.start.point,
            this.graph.start.direction,
            ...this.graph.nodes,
            this.graph.end.direction,
            this.graph.end.point,
        ]).forEach((points, index) => this.drawGraph(points));
    }
    /**
     * @param {?} x
     * @return {?}
     */
    animateGraph(x) {
        /** @type {?} */
        const graphs = this.spreadLines([
            this.graph.start.point,
            this.graph.start.direction,
            ...this.graph.nodes.map((point, i) => {
                /** @type {?} */
                const 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((points, i) => this.updateGraph(points, i));
    }
    /**
     * @param {?} points
     * @return {?}
     */
    spreadLines(points) {
        /** @type {?} */
        const shiftedMedians = [];
        /** @type {?} */
        const genshiftedMedians = this.graphService.spreadOrthogonal(this.medianPoint, this.graph.spread.spacing);
        for (let i = 0; i < this.graph.spread.amount; i++) {
            shiftedMedians.push(genshiftedMedians.next().value);
        }
        return shiftedMedians.map(median => {
            /** @type {?} */
            const shiftedPoints = points.slice();
            shiftedPoints.splice(this.medianIndex, 1, median);
            return shiftedPoints;
        });
    }
    /**
     * @param {?} points
     * @param {?} index
     * @return {?}
     */
    updateGraph(points, index) {
        this.pathElements[index]
            .attr('d', Shape.line()
            .x(p => p.x)
            .y(p => p.y)
            .curve(Shape.curveBasis)(points));
    }
    /**
     * @param {?} points
     * @return {?}
     */
    drawGraph(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', Shape.line()
            .x(p => p.x)
            .y(p => p.y)
            .curve(Shape.curveBasis)(points)));
    }
    /**
     * @param {?} points
     * @return {?}
     */
    debugGraph(points) {
        points.forEach((point, index) => {
            /** @type {?} */
            const 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 = () => [
    { type: NlsCanvasService },
    { type: ElementRef },
    { type: NlsMathService },
    { type: NlsGraphService }
];
NlsGuillocheDirective.propDecorators = {
    graph: [{ type: Input }],
    animation: [{ type: Input }]
};
function NlsGuillocheDirective_tsickle_Closure_declarations() {
    /** @type {?} */
    NlsGuillocheDirective.prototype.canvas;
    /** @type {?} */
    NlsGuillocheDirective.prototype.group;
    /** @type {?} */
    NlsGuillocheDirective.prototype.bounce;
    /** @type {?} */
    NlsGuillocheDirective.prototype.bounces;
    /** @type {?} */
    NlsGuillocheDirective.prototype.initialNodes;
    /** @type {?} */
    NlsGuillocheDirective.prototype.initialCurve;
    /** @type {?} */
    NlsGuillocheDirective.prototype.animationInterval;
    /** @type {?} */
    NlsGuillocheDirective.prototype.medianPoint;
    /** @type {?} */
    NlsGuillocheDirective.prototype.medianIndex;
    /** @type {?} */
    NlsGuillocheDirective.prototype.pathElements;
    /** @type {?} */
    NlsGuillocheDirective.prototype.graph;
    /** @type {?} */
    NlsGuillocheDirective.prototype.animation;
    /** @type {?} */
    NlsGuillocheDirective.prototype.canvasService;
    /** @type {?} */
    NlsGuillocheDirective.prototype.el;
    /** @type {?} */
    NlsGuillocheDirective.prototype.math;
    /** @type {?} */
    NlsGuillocheDirective.prototype.graphService;
}

//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guilloche.directive.js","sourceRoot":"ng://nls-guilloche/","sources":["nls/directives/guilloche.directive.ts"],"names":[],"mappings":"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","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 { 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"]}