core-graphics/lib/utils/transform.js

A core library for creating shape-based graphic editors

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.getScaleMatrix = exports.getTranslateMatrix = exports.getCol3FromPoint = exports.flip = exports.multiply = undefined;

var _matrixUtilities = require('matrix-utilities');

Object.defineProperty(exports, 'multiply', {
    enumerable: true,
    get: function get() {
        return _matrixUtilities.multiply;
    }
});
Object.defineProperty(exports, 'flip', {
    enumerable: true,
    get: function get() {
        return _matrixUtilities.flip;
    }
});
exports.getResizeOrigin = getResizeOrigin;
exports.getResizeCoeffs = getResizeCoeffs;
exports.transformShapeKeyPoints = transformShapeKeyPoints;
exports.moveShapeKeyPoints = moveShapeKeyPoints;
exports.scaleShapeKeyPoints = scaleShapeKeyPoints;

var _math = require('../utils/math');

var getCol3FromPoint = exports.getCol3FromPoint = function getCol3FromPoint(x, y) {
    return [[x], [y], [1]];
};
var getTranslateMatrix = exports.getTranslateMatrix = function getTranslateMatrix(dx, dy) {
    return [[1, 0, dx], [0, 1, dy], [0, 0, 1]];
};
var getScaleMatrix = exports.getScaleMatrix = function getScaleMatrix(kx, ky) {
    return [[kx, 0, 0], [0, ky, 0], [0, 0, 1]];
};
// mirrors the handle, for now
function getResizeOrigin(params) {
    var handle = params.handle;
    var bb = params.bb;
    var x1 = bb.x1;
    var y1 = bb.y1;
    var x2 = bb.x2;
    var y2 = bb.y2;
    var width = bb.width;
    var height = bb.height;
    var relX = handle.relX;
    var relY = handle.relY;

    var centerX = (x1 + x2) / 2;
    var centerY = (y1 + y2) / 2;
    var x = centerX - relX * width / 2;
    var y = centerY - relY * height / 2;
    return { x: x, y: y };
}
var padResizeCoeff = function padResizeCoeff(a, b) {
    if (Math.abs(b) === 0) {
        return 1;
    }
    // if (Math.abs(b) < SHAPE_BB_PADDING) return (1 + SHAPE_BB_PADDING);
    // if ((a / b) < 1 / SHAPE_BB_PADDING) return (1 / SHAPE_BB_PADDING); //TODO FIX
    return a / b;
};
function getResizeCoeffs(params) {
    var pOrigin = params.pOrigin;
    var pEnd = params.pEnd;
    var pStart = params.pStart;
    var proportional = params.proportional;
    var minWidth = params.minWidth;
    var minHeight = params.minHeight;

    var doh = {
        x: pStart.x - pOrigin.x,
        y: pStart.y - pOrigin.y
    };
    var dod = {
        x: pEnd.x - pOrigin.x,
        y: pEnd.y - pOrigin.y
    };
    var paddedDod = {
        x: (0, _math.padNumAbs)({ minAbs: minWidth, x: dod.x }),
        y: (0, _math.padNumAbs)({ minAbs: minHeight, x: dod.y })
    };
    var kx = padResizeCoeff(paddedDod.x, doh.x);
    var ky = padResizeCoeff(paddedDod.y, doh.y);
    if (proportional) {
        if ((0, _math.approxEqual)(pOrigin.x, pStart.x)) {
            return { kx: ky, ky: ky };
        }
        if ((0, _math.approxEqual)(pOrigin.y, pStart.y)) {
            return { kx: kx, ky: kx };
        }
        var k = Math.max(Math.abs(kx), Math.abs(ky));
        var signKx = (0, _math.sign)(kx);
        var signKy = (0, _math.sign)(ky);
        return { kx: k * signKx, ky: k * signKy };
    }
    return { kx: kx, ky: ky };
}
function transformShapeKeyPoints(transformMatrix, data) {
    var keyPoints = data.keyPoints;

    var transformedKeyPoints = keyPoints.map(function (point) {
        var x = point.x;
        var y = point.y;

        var res = (0, _matrixUtilities.multiply)(transformMatrix, getCol3FromPoint(x, y));
        var px = res[0][0];
        var py = res[1][0];
        if (point.payload) {
            return { x: px, y: py, payload: point.payload };
        }
        return { x: px, y: py };
    });
    return Object.assign({}, data, { keyPoints: transformedKeyPoints });
}
function moveShapeKeyPoints(delta, data) {
    var dx = delta.dx;
    var dy = delta.dy;

    var transformMatrix = getTranslateMatrix(dx, dy);
    return transformShapeKeyPoints(transformMatrix, data);
}
function scaleShapeKeyPoints(origin, scale, data) {
    var oX = origin.oX;
    var oY = origin.oY;
    var kx = scale.kx;
    var ky = scale.ky;

    var T1 = getTranslateMatrix(-oX, -oY);
    var S = getScaleMatrix(kx, ky);
    var T2 = getTranslateMatrix(oX, oY);
    var transformMatrix = (0, _matrixUtilities.multiply)(T2, (0, _matrixUtilities.multiply)(S, T1));
    return transformShapeKeyPoints(transformMatrix, data);
}