906 lines
82 KiB
JavaScript
906 lines
82 KiB
JavaScript
import { Injectable, RendererFactory2, ViewChild, Component, Input, Output, EventEmitter, HostListener, ElementRef, Directive, NgModule } from '@angular/core';
|
|
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
|
|
*/
|
|
class NlsCanvasService {
|
|
/**
|
|
* @param {?} rendererFactory
|
|
*/
|
|
constructor(rendererFactory) {
|
|
this.rendererFactory = rendererFactory;
|
|
this.renderer = rendererFactory.createRenderer(null, null);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get get() {
|
|
return this.canvas;
|
|
}
|
|
/**
|
|
* @param {?} el
|
|
* @return {?}
|
|
*/
|
|
set(el) {
|
|
this.canvas = el;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
adjustToWindow() {
|
|
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 = () => [
|
|
{ type: RendererFactory2 }
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
class NlsHistoryService {
|
|
constructor() {
|
|
this.history = [];
|
|
}
|
|
/**
|
|
* @param {?} graphs
|
|
* @param {?} config
|
|
* @return {?}
|
|
*/
|
|
save(graphs, config) {
|
|
this.history.push({
|
|
date: new Date(),
|
|
graphs: graphs,
|
|
config: config,
|
|
hash: this.hash(graphs)
|
|
});
|
|
}
|
|
/**
|
|
* @param {?} graphs
|
|
* @return {?}
|
|
*/
|
|
hash(graphs) {
|
|
return btoa(JSON.stringify(graphs));
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
list() {
|
|
return this.history;
|
|
}
|
|
}
|
|
NlsHistoryService.decorators = [
|
|
{ type: Injectable },
|
|
];
|
|
/** @nocollapse */
|
|
NlsHistoryService.ctorParameters = () => [];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
class NlsMathService {
|
|
/**
|
|
* Calculate distance between to points with coordinates.
|
|
* @param {?} a
|
|
* @param {?} b
|
|
* @return {?}
|
|
*/
|
|
Δ(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 {?}
|
|
*/
|
|
getClosestCenter(point, matrix) {
|
|
if (this.Δ(point, matrix.start) < this.Δ(point, matrix.end)) {
|
|
return matrix.start;
|
|
}
|
|
else {
|
|
return matrix.end;
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} matrix
|
|
* @return {?}
|
|
*/
|
|
getFarestCenter(point, matrix) {
|
|
if (this.Δ(point, matrix.start) > this.Δ(point, matrix.end)) {
|
|
return matrix.start;
|
|
}
|
|
else {
|
|
return matrix.end;
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} matrix
|
|
* @param {?} overlap
|
|
* @return {?}
|
|
*/
|
|
randomPoint(matrix, overlap) {
|
|
/** @type {?} */
|
|
const x = {
|
|
min: matrix.center.x - matrix.width * overlap,
|
|
max: matrix.center.x + matrix.width * overlap
|
|
};
|
|
/** @type {?} */
|
|
const 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 {?}
|
|
*/
|
|
centerOfArea(width, height) {
|
|
return {
|
|
x: width * 0.5,
|
|
y: height * 0.5
|
|
};
|
|
}
|
|
/**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
centerOfPoints(p1, p2) {
|
|
return {
|
|
x: (p1.x + p2.x) * 0.5,
|
|
y: (p1.y + p2.y) * 0.5
|
|
};
|
|
}
|
|
/**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
centerOfCurve(curve) {
|
|
/** @type {?} */
|
|
const genMedian = this.medianPoint(curve);
|
|
/** @type {?} */
|
|
const p1 = genMedian.next().value;
|
|
/** @type {?} */
|
|
const p2 = genMedian.next().value;
|
|
/** @type {?} */
|
|
const radians = this.angleRadians(p1, p2);
|
|
return Object.assign(this.centerOfPoints(p1, p2), { ascent: radians });
|
|
}
|
|
/**
|
|
* @param {?} curve
|
|
* @return {?}
|
|
*/
|
|
medianOfCurve(curve) {
|
|
/** @type {?} */
|
|
const genMedian = this.medianPoint(curve);
|
|
/** @type {?} */
|
|
const p1 = genMedian.next().value;
|
|
/** @type {?} */
|
|
const p2 = genMedian.next().value;
|
|
/** @type {?} */
|
|
const p3 = genMedian.next().value;
|
|
/** @type {?} */
|
|
const 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 {?}
|
|
*/
|
|
angleRadians(p1, p2) {
|
|
return Math.atan2(p2.y - p1.y, p2.x - p1.x);
|
|
}
|
|
/**
|
|
* @param {?} p1
|
|
* @param {?} p2
|
|
* @return {?}
|
|
*/
|
|
angleDegree(p1, p2) {
|
|
return this.angleRadians(p1, p2) * 180 / Math.PI;
|
|
}
|
|
/**
|
|
* @param {?} list
|
|
* @return {?}
|
|
*/
|
|
medianIndex(list) {
|
|
return Math.floor(list.length * 0.5);
|
|
}
|
|
/**
|
|
* @param {?} points
|
|
* @return {?}
|
|
*/
|
|
*medianPoint(points) {
|
|
/** @type {?} */
|
|
let index;
|
|
/** @type {?} */
|
|
const list = points.slice();
|
|
while (list) {
|
|
index = this.medianIndex(points);
|
|
yield list[index];
|
|
list.splice(index, 1);
|
|
}
|
|
}
|
|
/**
|
|
* 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 {?}
|
|
*/
|
|
*bounce(amplitude = 1, decimals = 1, start = 0) {
|
|
/** @type {?} */
|
|
const power = Math.pow(10, decimals);
|
|
/** @type {?} */
|
|
const step = 2 / (power);
|
|
/** @type {?} */
|
|
let index = 0;
|
|
while (true) {
|
|
/** @type {?} */
|
|
const radians = Math.PI * step * index + start;
|
|
yield Math.round((Math.sin(radians) * amplitude) * power) / power;
|
|
index++;
|
|
}
|
|
}
|
|
/**
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
*flipSign(startPositive = true) {
|
|
/** @type {?} */
|
|
let sign = startPositive ? 1 : -1;
|
|
while (true) {
|
|
yield sign = sign * (-1);
|
|
}
|
|
}
|
|
}
|
|
NlsMathService.decorators = [
|
|
{ type: Injectable },
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
class NlsGraphService {
|
|
/**
|
|
* @param {?} math
|
|
*/
|
|
constructor(math) {
|
|
this.math = math;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get() {
|
|
return this.graphs;
|
|
}
|
|
/**
|
|
* @param {?} newGraphs
|
|
* @return {?}
|
|
*/
|
|
set(newGraphs) {
|
|
this.graphs = newGraphs;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
get isAnimated() {
|
|
return this.animation;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
startAnimation() {
|
|
this.animation = true;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
stopAnimation() {
|
|
this.animation = false;
|
|
}
|
|
/**
|
|
* @param {?} start
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
*spreadOrthogonal(start, spacing) {
|
|
/** @type {?} */
|
|
const sign = this.math.flipSign();
|
|
/** @type {?} */
|
|
let currentPoint = start;
|
|
/** @type {?} */
|
|
let i = 0;
|
|
while (true) {
|
|
/** @type {?} */
|
|
const currentSpacing = sign.next().value * spacing * i;
|
|
currentPoint = this.shiftPoint(currentPoint, start.ascent, currentSpacing);
|
|
yield currentPoint;
|
|
i++;
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} point
|
|
* @param {?} radians
|
|
* @param {?} spacing
|
|
* @return {?}
|
|
*/
|
|
shiftPoint(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 = () => [
|
|
{ type: NlsMathService }
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
/** @type {?} */
|
|
const RESIZING_TIMEOUT = 800;
|
|
class NlsGraphsComponent {
|
|
/**
|
|
* @param {?} canvasService
|
|
* @param {?} historyService
|
|
* @param {?} math
|
|
* @param {?} graphService
|
|
*/
|
|
constructor(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 {?}
|
|
*/
|
|
onResize(event) {
|
|
clearTimeout(this.resizingWindow);
|
|
this.resizingWindow = setTimeout(() => {
|
|
this.canvas = this.adjustCanvas();
|
|
this.matrix = this.calcMatrix();
|
|
this.updateGraphs();
|
|
}, RESIZING_TIMEOUT);
|
|
}
|
|
/**
|
|
* @param {?} changes
|
|
* @return {?}
|
|
*/
|
|
ngOnChanges(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 {?}
|
|
*/
|
|
restoreGraph() {
|
|
this.graphs = this.restoredHistory.graphs;
|
|
this.hash = this.restoredHistory.hash;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
saveHistory() {
|
|
this.hash = this.historyService.hash(this.graphs);
|
|
this.historyService.save(this.graphs, this.config);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
saveGraph() {
|
|
this.graphService.set(this.graphs);
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
updateGraphs() {
|
|
/** @type {?} */
|
|
const genShiftStart = this.shiftPoint(this.matrix.start, this.config.vectors.start);
|
|
/** @type {?} */
|
|
const genShiftEnd = this.shiftPoint(this.matrix.end, this.config.vectors.end, false);
|
|
console.log(this.matrix);
|
|
/** @type {?} */
|
|
const 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(curve => {
|
|
return Object.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 {?}
|
|
*/
|
|
adjustGraph(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 {?}
|
|
*/
|
|
genRandomPoints(num) {
|
|
/** @type {?} */
|
|
const generatedPoints = [];
|
|
for (let i = 0; i < this.config.nodes; i++) {
|
|
generatedPoints.push(this.math.randomPoint(this.matrix, this.config.overlap));
|
|
}
|
|
return generatedPoints;
|
|
}
|
|
/**
|
|
* @param {?} x
|
|
* @return {?}
|
|
*/
|
|
flipflop(x) {
|
|
return (x === 'start') ? 'end' : 'start';
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
adjustCanvas() {
|
|
this.canvasService.set(this.canvas);
|
|
this.canvasService.adjustToWindow();
|
|
return this.svgElementRef.nativeElement;
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
calcMatrix() {
|
|
/** @type {?} */
|
|
const canvasWidth = this.canvas.getBoundingClientRect().width;
|
|
/** @type {?} */
|
|
const canvasHeight = this.canvas.getBoundingClientRect().height;
|
|
/** @type {?} */
|
|
const 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 {?}
|
|
*/
|
|
genVectorPoint(point, vector) {
|
|
/** @type {?} */
|
|
const 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 {?}
|
|
*/
|
|
*shiftPoint(point, vector, startPositive = true) {
|
|
/** @type {?} */
|
|
const genShiftX = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
|
|
/** @type {?} */
|
|
const genShiftY = this.shiftNumber(this.config.vectors.spacing, vector, startPositive);
|
|
while (true) {
|
|
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
|
|
};
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} space
|
|
* @param {?} vector
|
|
* @param {?=} startPositive
|
|
* @return {?}
|
|
*/
|
|
*shiftNumber(space, vector, startPositive = true) {
|
|
/** @type {?} */
|
|
let current = 0;
|
|
/** @type {?} */
|
|
let index = 0;
|
|
/** @type {?} */
|
|
const sign = this.math.flipSign(startPositive);
|
|
while (true) {
|
|
yield current = sign.next().value * index * space + current;
|
|
index++;
|
|
}
|
|
}
|
|
/**
|
|
* @param {?} guillocheElement
|
|
* @return {?}
|
|
*/
|
|
prepareGuillocheExport(guillocheElement) {
|
|
if (this.genLoadedAllGraphs.next().value) {
|
|
this.svgChange.emit(this.svgElementRef);
|
|
}
|
|
}
|
|
/**
|
|
* @return {?}
|
|
*/
|
|
*countLoadedGraphs() {
|
|
/** @type {?} */
|
|
let cycles = 1;
|
|
while (true) {
|
|
if (cycles < this.graphs.length) {
|
|
yield false;
|
|
cycles++;
|
|
}
|
|
else {
|
|
yield true;
|
|
cycles = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
NlsGraphsComponent.decorators = [
|
|
{ type: Component, args: [{
|
|
selector: 'nls-graphs',
|
|
template: `<svg #svg width="100%" height="100%" xmlns="http://www.w3.org/2000/svg"
|
|
version="1.1" shape-rendering="geometricPrecision">
|
|
<g nlsGuilloche *ngFor="let graph of graphs" [graph]="graph" [animation]="animation"></g>
|
|
</svg>
|
|
`,
|
|
styles: [`:host{position:absolute;width:100%;height:100%;top:0;left:0;overflow:hidden}`]
|
|
},] },
|
|
];
|
|
/** @nocollapse */
|
|
NlsGraphsComponent.ctorParameters = () => [
|
|
{ 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'],] }]
|
|
};
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
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 = 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 = [
|
|
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', line()
|
|
.x(p => p.x)
|
|
.y(p => p.y)
|
|
.curve(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', line()
|
|
.x(p => p.x)
|
|
.y(p => p.y)
|
|
.curve(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 }]
|
|
};
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
class NlsAnimationService {
|
|
/**
|
|
* @param {?} math
|
|
* @param {?} historyService
|
|
*/
|
|
constructor(math, historyService) {
|
|
this.math = math;
|
|
this.historyService = historyService;
|
|
}
|
|
/**
|
|
* @param {?} initialGraph
|
|
* @return {?}
|
|
*/
|
|
animate(initialGraph) {
|
|
/** @type {?} */
|
|
const newGraph = Object.assign({}, initialGraph);
|
|
/** @type {?} */
|
|
const indexMiddle = Math.floor(newGraph.nodes.length * 0.5);
|
|
/** @type {?} */
|
|
const 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 = () => [
|
|
{ type: NlsMathService },
|
|
{ type: NlsHistoryService }
|
|
];
|
|
|
|
/**
|
|
* @fileoverview added by tsickle
|
|
* @suppress {checkTypes} checked by tsc
|
|
*/
|
|
class NlsGuillocheModule {
|
|
}
|
|
NlsGuillocheModule.decorators = [
|
|
{ type: NgModule, args: [{
|
|
imports: [
|
|
BrowserModule
|
|
],
|
|
declarations: [
|
|
NlsGraphsComponent,
|
|
NlsGuillocheDirective
|
|
],
|
|
providers: [
|
|
NlsHistoryService,
|
|
NlsCanvasService,
|
|
NlsMathService,
|
|
NlsGraphService,
|
|
],
|
|
exports: [
|
|
NlsGraphsComponent,
|
|
NlsGuillocheDirective
|
|
]
|
|
},] },
|
|
];
|
|
|
|
/**
|
|
* @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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"}
|