@autonomdev/ngx-document-scanner
Version:
Angular 2+ component for cropping and enhancing images of documents
357 lines • 28.9 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/services/limits.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Injectable } from '@angular/core';
import { BehaviorSubject } from 'rxjs';
import * as i0 from "@angular/core";
export class LimitsService {
constructor() {
this.limitDirections = ['left', 'right', 'top', 'bottom'];
/**
* stores the crop limits limits
*/
this._limits = {
top: 0,
bottom: 0,
right: 0,
left: 0
};
/**
* stores the array of the draggable points displayed on the crop area
*/
this._points = [];
// *********** //
// Observables //
// *********** //
this.positions = new BehaviorSubject(Array.from(this._points));
this.repositionEvent = new BehaviorSubject([]);
this.limits = new BehaviorSubject(this._limits);
this.paneDimensions = new BehaviorSubject({ width: 0, height: 0 });
}
/**
* set privew pane dimensions
* @param {?} dimensions
* @return {?}
*/
setPaneDimensions(dimensions) {
return new Promise((/**
* @param {?} resolve
* @param {?} reject
* @return {?}
*/
(resolve, reject) => {
this._paneDimensions = dimensions;
this.paneDimensions.next(dimensions);
resolve();
}));
}
/**
* repositions points externally
* @param {?} positions
* @return {?}
*/
repositionPoints(positions) {
this._points = positions;
positions.forEach((/**
* @param {?} position
* @return {?}
*/
position => {
this.positionChange(position);
}));
this.repositionEvent.next(positions);
}
/**
* updates limits and point positions and calls next on the observables
* @param {?} positionChangeData - position change event data
* @return {?}
*/
positionChange(positionChangeData) {
// update positions according to current position change
this.updatePosition(positionChangeData);
// for each direction:
// 1. filter the _points that have a role as the direction's limit
// 2. for top and left find max x | y values, and min for right and bottom
this.limitDirections.forEach((/**
* @param {?} direction
* @return {?}
*/
direction => {
/** @type {?} */
const relevantPoints = this._points.filter((/**
* @param {?} point
* @return {?}
*/
point => {
return point.roles.includes(direction);
}))
.map((/**
* @param {?} point
* @return {?}
*/
(point) => {
return point[this.getDirectionAxis(direction)];
}));
/** @type {?} */
let limit;
if (direction === 'top' || direction === 'left') {
limit = Math.max(...relevantPoints);
}
if (direction === 'right' || direction === 'bottom') {
limit = Math.min(...relevantPoints);
}
this._limits[direction] = limit;
}));
this.limits.next(this._limits);
this.positions.next(Array.from(this._points));
}
/**
* updates the position of the point
* @param {?} positionChange - position change event data
* @return {?}
*/
updatePosition(positionChange) {
// finds the current position of the point by it's roles, than splices it for the new position or pushes it if it's not yet in the array
/** @type {?} */
const index = this._points.findIndex((/**
* @param {?} point
* @return {?}
*/
point => {
return this.compareArray(positionChange.roles, point.roles);
}));
if (index === -1) {
this._points.push(positionChange);
}
else {
this._points.splice(index, 1, positionChange);
}
}
/**
* check if a position change event exceeds the limits
* @param {?} positionChange - position change event data
* @return {?} LimitException0
*/
exceedsLimit(positionChange) {
/** @type {?} */
const pointLimits = this.limitDirections.filter((/**
* @param {?} direction
* @return {?}
*/
direction => {
return !positionChange.roles.includes(direction);
}));
/** @type {?} */
const limitException = {
exceeds: false,
resetCoefficients: {
x: 0,
y: 0
},
resetCoordinates: {
x: positionChange.x,
y: positionChange.y
}
};
// limit directions are the opposite sides of the point's roles
pointLimits.forEach((/**
* @param {?} direction
* @return {?}
*/
direction => {
/** @type {?} */
const directionAxis = this.getDirectionAxis(direction);
if (direction === 'top' || direction === 'left') {
if (positionChange[directionAxis] < this._limits[direction]) {
limitException.resetCoefficients[directionAxis] = 1;
limitException.resetCoordinates[directionAxis] = this._limits[direction];
}
}
else if (direction === 'right' || direction === 'bottom') {
if (positionChange[directionAxis] > this._limits[direction]) {
limitException.resetCoefficients[directionAxis] = -1;
limitException.resetCoordinates[directionAxis] = this._limits[direction];
}
}
}));
if (limitException.resetCoefficients.x !== 0 || limitException.resetCoefficients.y !== 0) {
limitException.exceeds = true;
}
return limitException;
}
/**
* rotate crop tool points clockwise
* @param {?} resizeRatios - ratio between the new dimensions and the previous
* @param {?} initialPreviewDimensions - preview pane dimensions before rotation
* @param {?} initialPositions - current positions before rotation
* @return {?}
*/
rotateClockwise(resizeRatios, initialPreviewDimensions, initialPositions) {
// convert positions to ratio between position to initial pane dimension
initialPositions = initialPositions.map((/**
* @param {?} point
* @return {?}
*/
point => {
return new PositionChangeData({
x: point.x / initialPreviewDimensions.width,
y: point.y / initialPreviewDimensions.height,
}, point.roles);
}));
this.repositionPoints(initialPositions.map((/**
* @param {?} point
* @return {?}
*/
point => {
return this.rotateCornerClockwise(point);
})));
}
/**
* returns the corner positions after a 90 degrees clockwise rotation
* @private
* @param {?} corner
* @return {?}
*/
rotateCornerClockwise(corner) {
/** @type {?} */
const rotated = {
x: this._paneDimensions.width * (1 - corner.y),
y: this._paneDimensions.height * corner.x,
roles: []
};
// rotates corner according to order
/** @type {?} */
const order = [
['bottom', 'left'],
['top', 'left'],
['top', 'right'],
['bottom', 'right'],
['bottom', 'left']
];
rotated.roles = order[order.findIndex((/**
* @param {?} roles
* @return {?}
*/
roles => {
return this.compareArray(roles, corner.roles);
})) + 1];
return rotated;
}
/**
* checks if two array contain the same values
* @param {?} array1 - array 1
* @param {?} array2 - array 2
* @return {?} boolean
*/
compareArray(array1, array2) {
return array1.every((/**
* @param {?} element
* @return {?}
*/
(element) => {
return array2.includes(element);
})) && array1.length === array2.length;
}
/**
* @private
* @param {?} direction
* @return {?}
*/
getDirectionAxis(direction) {
return {
left: 'x',
right: 'x',
top: 'y',
bottom: 'y'
}[direction];
}
}
LimitsService.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */
LimitsService.ctorParameters = () => [];
/** @nocollapse */ LimitsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LimitsService_Factory() { return new LimitsService(); }, token: LimitsService, providedIn: "root" });
if (false) {
/**
* @type {?}
* @private
*/
LimitsService.prototype.limitDirections;
/**
* stores the crop limits limits
* @type {?}
* @private
*/
LimitsService.prototype._limits;
/**
* stores the array of the draggable points displayed on the crop area
* @type {?}
* @private
*/
LimitsService.prototype._points;
/**
* stores the pane dimensions
* @type {?}
* @private
*/
LimitsService.prototype._paneDimensions;
/** @type {?} */
LimitsService.prototype.positions;
/** @type {?} */
LimitsService.prototype.repositionEvent;
/** @type {?} */
LimitsService.prototype.limits;
/** @type {?} */
LimitsService.prototype.paneDimensions;
}
/**
* @record
*/
export function PointPositionChange() { }
if (false) {
/** @type {?} */
PointPositionChange.prototype.x;
/** @type {?} */
PointPositionChange.prototype.y;
/** @type {?} */
PointPositionChange.prototype.roles;
}
/**
* @record
*/
export function AreaLimits() { }
if (false) {
/** @type {?} */
AreaLimits.prototype.top;
/** @type {?} */
AreaLimits.prototype.bottom;
/** @type {?} */
AreaLimits.prototype.right;
/** @type {?} */
AreaLimits.prototype.left;
}
export class PositionChangeData {
/**
* @param {?} position
* @param {?} roles
*/
constructor(position, roles) {
this.x = position.x;
this.y = position.y;
this.roles = roles;
}
}
if (false) {
/** @type {?} */
PositionChangeData.prototype.x;
/** @type {?} */
PositionChangeData.prototype.y;
/** @type {?} */
PositionChangeData.prototype.roles;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"limits.service.js","sourceRoot":"ng://@autonomdev/ngx-document-scanner/","sources":["lib/services/limits.service.ts"],"names":[],"mappings":";;;;;AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AACzC,OAAO,EAAC,eAAe,EAAC,MAAM,MAAM,CAAC;;AAOrC,MAAM,OAAO,aAAa;IA8BxB;QA3BQ,oBAAe,GAAe,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;;;;QAIjE,YAAO,GAAG;YAChB,GAAG,EAAE,CAAC;YACN,MAAM,EAAE,CAAC;YACT,KAAK,EAAE,CAAC;YACR,IAAI,EAAE,CAAC;SACR,CAAC;;;;QAIM,YAAO,GAA+B,EAAE,CAAC;;;;QAS1C,cAAS,GAAgD,IAAI,eAAe,CAA6B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;QACnI,oBAAe,GAAgD,IAAI,eAAe,CAA6B,EAAE,CAAC,CAAC;QACnH,WAAM,GAAgC,IAAI,eAAe,CAAa,IAAI,CAAC,OAAO,CAAC,CAAC;QACpF,mBAAc,GAAqC,IAAI,eAAe,CAAC,EAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAC,CAAC,CAAC;IAGrG,CAAC;;;;;;IAKM,iBAAiB,CAAC,UAA2B;QAClD,OAAO,IAAI,OAAO;;;;;QAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC;YAClC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACrC,OAAO,EAAE,CAAC;QACZ,CAAC,EAAC,CAAC;IACL,CAAC;;;;;;IAKM,gBAAgB,CAAC,SAAS;QAC/B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;QACzB,SAAS,CAAC,OAAO;;;;QAAC,QAAQ,CAAC,EAAE;YAC3B,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC,EAAC,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;;;;;;IAMM,cAAc,CAAC,kBAAuC;QAC3D,wDAAwD;QACxD,IAAI,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;QAExC,sBAAsB;QACtB,kEAAkE;QAClE,0EAA0E;QAC1E,IAAI,CAAC,eAAe,CAAC,OAAO;;;;QAAC,SAAS,CAAC,EAAE;;kBACjC,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM;;;;YAAC,KAAK,CAAC,EAAE;gBACjD,OAAO,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;YACzC,CAAC,EAAC;iBACC,GAAG;;;;YAAC,CAAC,KAA0B,EAAE,EAAE;gBAClC,OAAO,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC;YACjD,CAAC,EAAC;;gBACA,KAAK;YACT,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,EAAE;gBAC/C,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC;aACrC;YACD,IAAI,SAAS,KAAK,OAAO,IAAI,SAAS,KAAK,QAAQ,EAAE;gBACnD,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,CAAC;aACrC;YACD,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC;QAClC,CAAC,EAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC/B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAChD,CAAC;;;;;;IAMM,cAAc,CAAC,cAAmC;;;cAEjD,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS;;;;QAAC,KAAK,CAAC,EAAE;YAC3C,OAAO,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAC9D,CAAC,EAAC;QACF,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YAChB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;SACnC;aAAM;YACL,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;SAC/C;IACH,CAAC;;;;;;IAOM,YAAY,CAAC,cAAmC;;cAC/C,WAAW,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM;;;;QAAC,SAAS,CAAC,EAAE;YAC1D,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;QACnD,CAAC,EAAC;;cAEI,cAAc,GAAmB;YACrC,OAAO,EAAE,KAAK;YACd,iBAAiB,EAAE;gBACjB,CAAC,EAAE,CAAC;gBACJ,CAAC,EAAE,CAAC;aACL;YACD,gBAAgB,EAAE;gBAChB,CAAC,EAAE,cAAc,CAAC,CAAC;gBACnB,CAAC,EAAE,cAAc,CAAC,CAAC;aACpB;SACF;QAED,+DAA+D;QAC/D,WAAW,CAAC,OAAO;;;;QAAC,SAAS,CAAC,EAAE;;kBACxB,aAAa,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC;YACtD,IAAI,SAAS,KAAK,KAAK,IAAI,SAAS,KAAK,MAAM,EAAE;gBAC/C,IAAI,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;oBAC3D,cAAc,CAAC,iBAAiB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;oBACpD,cAAc,CAAC,gBAAgB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;iBAC1E;aACF;iBAAM,IAAI,SAAS,KAAK,OAAO,IAAI,SAAS,KAAK,QAAQ,EAAE;gBAC1D,IAAI,cAAc,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;oBAC3D,cAAc,CAAC,iBAAiB,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;oBACrD,cAAc,CAAC,gBAAgB,CAAC,aAAa,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;iBAC1E;aACF;QACH,CAAC,EAAC,CAAC;QAEH,IAAI,cAAc,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,iBAAiB,CAAC,CAAC,KAAK,CAAC,EAAE;YACxF,cAAc,CAAC,OAAO,GAAG,IAAI,CAAC;SAC/B;QAED,OAAO,cAAc,CAAC;IACxB,CAAC;;;;;;;;IAQM,eAAe,CAAC,YAAY,EAAE,wBAAwB,EAAE,gBAA4C;QACzG,wEAAwE;QACxE,gBAAgB,GAAG,gBAAgB,CAAC,GAAG;;;;QAAC,KAAK,CAAC,EAAE;YAC9C,OAAO,IAAI,kBAAkB,CAAC;gBAC5B,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,wBAAwB,CAAC,KAAK;gBAC3C,CAAC,EAAE,KAAK,CAAC,CAAC,GAAG,wBAAwB,CAAC,MAAM;aAC7C,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC,EAAC,CAAC;QACH,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,GAAG;;;;QAAC,KAAK,CAAC,EAAE;YACjD,OAAO,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;QAC3C,CAAC,EAAC,CAAC,CAAC;IACN,CAAC;;;;;;;IAKO,qBAAqB,CAAC,MAA2B;;cACjD,OAAO,GAAwB;YACnC,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC;YAC9C,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;YACzC,KAAK,EAAE,EAAE;SACV;;;cAEK,KAAK,GAAsB;YAC/B,CAAC,QAAQ,EAAE,MAAM,CAAC;YAClB,CAAC,KAAK,EAAE,MAAM,CAAC;YACf,CAAC,KAAK,EAAE,OAAO,CAAC;YAChB,CAAC,QAAQ,EAAE,OAAO,CAAC;YACnB,CAAC,QAAQ,EAAE,MAAM,CAAC;SACnB;QACD,OAAO,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,SAAS;;;;QAAC,KAAK,CAAC,EAAE;YAC5C,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;QAChD,CAAC,EAAC,GAAG,CAAC,CAAC,CAAC;QACR,OAAO,OAAO,CAAC;IACjB,CAAC;;;;;;;IAQM,YAAY,CAAC,MAAqB,EAAE,MAAqB;QAC9D,OAAO,MAAM,CAAC,KAAK;;;;QAAC,CAAC,OAAO,EAAE,EAAE;YAC9B,OAAO,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC,EAAC,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC;IACxC,CAAC;;;;;;IAEO,gBAAgB,CAAC,SAAS;QAChC,OAAO;YACL,IAAI,EAAE,GAAG;YACT,KAAK,EAAE,GAAG;YACV,GAAG,EAAE,GAAG;YACR,MAAM,EAAE,GAAG;SACZ,CAAC,SAAS,CAAC,CAAC;IACf,CAAC;;;YApNF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;;;;;;;;IAIC,wCAAyE;;;;;;IAIzE,gCAKE;;;;;;IAIF,gCAAiD;;;;;;IAIjD,wCAAyC;;IAKzC,kCAA0I;;IAC1I,wCAA0H;;IAC1H,+BAA2F;;IAC3F,uCAAqG;;;;;AAyLvG,yCAIC;;;IAHC,gCAAU;;IACV,gCAAU;;IACV,oCAAkB;;;;;AAGpB,gCAKC;;;IAJC,yBAAY;;IACZ,4BAAe;;IACf,2BAAc;;IACd,0BAAa;;AAKf,MAAM,OAAO,kBAAkB;;;;;IAK7B,YAAY,QAAoB,EAAE,KAAiB;QACjD,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;QACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;CACF;;;IATC,+BAAU;;IACV,+BAAU;;IACV,mCAAkB","sourcesContent":["import {Injectable} from '@angular/core';\nimport {BehaviorSubject} from 'rxjs';\nimport {ImageDimensions} from '../PublicModels';\nimport {LimitException, XYPosition} from '../PrivateModels';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class LimitsService {\n\n\n  private limitDirections: RolesArray = ['left', 'right', 'top', 'bottom'];\n  /**\n   * stores the crop limits limits\n   */\n  private _limits = {\n    top: 0,\n    bottom: 0,\n    right: 0,\n    left: 0\n  };\n  /**\n   * stores the array of the draggable points displayed on the crop area\n   */\n  private _points: Array<PointPositionChange> = [];\n  /**\n   * stores the pane dimensions\n   */\n  private _paneDimensions: ImageDimensions;\n\n  // *********** //\n  // Observables //\n  // *********** //\n  public positions: BehaviorSubject<Array<PointPositionChange>> = new BehaviorSubject<Array<PointPositionChange>>(Array.from(this._points));\n  public repositionEvent: BehaviorSubject<Array<PointPositionChange>> = new BehaviorSubject<Array<PointPositionChange>>([]);\n  public limits: BehaviorSubject<AreaLimits> = new BehaviorSubject<AreaLimits>(this._limits);\n  public paneDimensions: BehaviorSubject<ImageDimensions> = new BehaviorSubject({width: 0, height: 0});\n\n  constructor() {\n  }\n\n  /**\n   * set privew pane dimensions\n   */\n  public setPaneDimensions(dimensions: ImageDimensions) {\n    return new Promise((resolve, reject) => {\n      this._paneDimensions = dimensions;\n      this.paneDimensions.next(dimensions);\n      resolve();\n    });\n  }\n\n  /**\n   * repositions points externally\n   */\n  public repositionPoints(positions) {\n    this._points = positions;\n    positions.forEach(position => {\n      this.positionChange(position);\n    });\n    this.repositionEvent.next(positions);\n  }\n\n  /**\n   * updates limits and point positions and calls next on the observables\n   * @param positionChangeData - position change event data\n   */\n  public positionChange(positionChangeData: PointPositionChange) {\n    // update positions according to current position change\n    this.updatePosition(positionChangeData);\n\n    // for each direction:\n    // 1. filter the _points that have a role as the direction's limit\n    // 2. for top and left find max x | y values, and min for right and bottom\n    this.limitDirections.forEach(direction => {\n      const relevantPoints = this._points.filter(point => {\n        return point.roles.includes(direction);\n      })\n        .map((point: PointPositionChange) => {\n          return point[this.getDirectionAxis(direction)];\n        });\n      let limit;\n      if (direction === 'top' || direction === 'left') {\n        limit = Math.max(...relevantPoints);\n      }\n      if (direction === 'right' || direction === 'bottom') {\n        limit = Math.min(...relevantPoints);\n      }\n      this._limits[direction] = limit;\n    });\n\n    this.limits.next(this._limits);\n    this.positions.next(Array.from(this._points));\n  }\n\n  /**\n   * updates the position of the point\n   * @param positionChange - position change event data\n   */\n  public updatePosition(positionChange: PointPositionChange) {\n    // finds the current position of the point by it's roles, than splices it for the new position or pushes it if it's not yet in the array\n    const index = this._points.findIndex(point => {\n      return this.compareArray(positionChange.roles, point.roles);\n    });\n    if (index === -1) {\n      this._points.push(positionChange);\n    } else {\n      this._points.splice(index, 1, positionChange);\n    }\n  }\n\n  /**\n   * check if a position change event exceeds the limits\n   * @param positionChange - position change event data\n   * @returns LimitException0\n   */\n  public exceedsLimit(positionChange: PointPositionChange): LimitException {\n    const pointLimits = this.limitDirections.filter(direction => {\n      return !positionChange.roles.includes(direction);\n    });\n\n    const limitException: LimitException = {\n      exceeds: false,\n      resetCoefficients: {\n        x: 0,\n        y: 0\n      },\n      resetCoordinates: {\n        x: positionChange.x,\n        y: positionChange.y\n      }\n    };\n\n    // limit directions are the opposite sides of the point's roles\n    pointLimits.forEach(direction => {\n      const directionAxis = this.getDirectionAxis(direction);\n      if (direction === 'top' || direction === 'left') {\n        if (positionChange[directionAxis] < this._limits[direction]) {\n          limitException.resetCoefficients[directionAxis] = 1;\n          limitException.resetCoordinates[directionAxis] = this._limits[direction];\n        }\n      } else if (direction === 'right' || direction === 'bottom') {\n        if (positionChange[directionAxis] > this._limits[direction]) {\n          limitException.resetCoefficients[directionAxis] = -1;\n          limitException.resetCoordinates[directionAxis] = this._limits[direction];\n        }\n      }\n    });\n\n    if (limitException.resetCoefficients.x !== 0 || limitException.resetCoefficients.y !== 0) {\n      limitException.exceeds = true;\n    }\n\n    return limitException;\n  }\n\n  /**\n   * rotate crop tool points clockwise\n   * @param resizeRatios - ratio between the new dimensions and the previous\n   * @param initialPreviewDimensions - preview pane dimensions before rotation\n   * @param initialPositions - current positions before rotation\n   */\n  public rotateClockwise(resizeRatios, initialPreviewDimensions, initialPositions: Array<PointPositionChange>) {\n    // convert positions to ratio between position to initial pane dimension\n    initialPositions = initialPositions.map(point => {\n      return new PositionChangeData({\n        x: point.x / initialPreviewDimensions.width,\n        y: point.y / initialPreviewDimensions.height,\n      }, point.roles);\n    });\n    this.repositionPoints(initialPositions.map(point => {\n      return this.rotateCornerClockwise(point);\n    }));\n  }\n\n  /**\n   * returns the corner positions after a 90 degrees clockwise rotation\n   */\n  private rotateCornerClockwise(corner: PointPositionChange): PointPositionChange {\n    const rotated: PointPositionChange = {\n      x: this._paneDimensions.width * (1 - corner.y),\n      y: this._paneDimensions.height * corner.x,\n      roles: []\n    };\n    // rotates corner according to order\n    const order: Array<RolesArray> = [\n      ['bottom', 'left'],\n      ['top', 'left'],\n      ['top', 'right'],\n      ['bottom', 'right'],\n      ['bottom', 'left']\n    ];\n    rotated.roles = order[order.findIndex(roles => {\n      return this.compareArray(roles, corner.roles);\n    }) + 1];\n    return rotated;\n  }\n\n  /**\n   * checks if two array contain the same values\n   * @param array1 - array 1\n   * @param array2 - array 2\n   * @returns boolean\n   */\n  public compareArray(array1: Array<string>, array2: Array<string>): boolean {\n    return array1.every((element) => {\n      return array2.includes(element);\n    }) && array1.length === array2.length;\n  }\n\n  private getDirectionAxis(direction) {\n    return {\n      left: 'x',\n      right: 'x',\n      top: 'y',\n      bottom: 'y'\n    }[direction];\n  }\n}\n\n\nexport interface PointPositionChange {\n  x: number;\n  y: number;\n  roles: RolesArray;\n}\n\nexport interface AreaLimits {\n  top: number;\n  bottom: number;\n  right: number;\n  left: number;\n}\n\nexport type RolesArray = Array<Direction>;\n\nexport class PositionChangeData implements PointPositionChange {\n  x: number;\n  y: number;\n  roles: RolesArray;\n\n  constructor(position: XYPosition, roles: RolesArray) {\n    this.x = position.x;\n    this.y = position.y;\n    this.roles = roles;\n  }\n}\n\nexport type Direction = 'left' | 'right' | 'top' | 'bottom';\n"]}