Current Path : C:/xampp/htdocs/moodle/lib/yuilib/3.17.2/matrix/ |
Current File : C:/xampp/htdocs/moodle/lib/yuilib/3.17.2/matrix/matrix.js |
/* YUI 3.17.2 (build 9c3c78e) Copyright 2014 Yahoo! Inc. All rights reserved. Licensed under the BSD License. http://yuilibrary.com/license/ */ YUI.add('matrix', function (Y, NAME) { /** * Matrix utilities. * * @class MatrixUtil * @module matrix **/ var MatrixUtil = { /** * Used as value for the _rounding method. * * @property _rounder * @private */ _rounder: 100000, /** * Rounds values * * @method _round * @private */ _round: function(val) { val = Math.round(val * MatrixUtil._rounder) / MatrixUtil._rounder; return val; }, /** * Converts a radian value to a degree. * * @method rad2deg * @param {Number} rad Radian value to be converted. * @return Number */ rad2deg: function(rad) { var deg = rad * (180 / Math.PI); return deg; }, /** * Converts a degree value to a radian. * * @method deg2rad * @param {Number} deg Degree value to be converted to radian. * @return Number */ deg2rad: function(deg) { var rad = deg * (Math.PI / 180); return rad; }, /** * Converts an angle to a radian * * @method angle2rad * @param {Objecxt} val Value to be converted to radian. * @return Number */ angle2rad: function(val) { if (typeof val === 'string' && val.indexOf('rad') > -1) { val = parseFloat(val); } else { // default to deg val = MatrixUtil.deg2rad(parseFloat(val)); } return val; }, /** * Converts a transform object to an array of column vectors. * * / \ * | matrix[0][0] matrix[1][0] matrix[2][0] | * | matrix[0][1] matrix[1][1] matrix[2][1] | * | matrix[0][2] matrix[1][2] matrix[2][2] | * \ / * * @method getnxn * @return Array */ convertTransformToArray: function(matrix) { var matrixArray = [ [matrix.a, matrix.c, matrix.dx], [matrix.b, matrix.d, matrix.dy], [0, 0, 1] ]; return matrixArray; }, /** * Returns the determinant of a given matrix. * * / \ * | matrix[0][0] matrix[1][0] matrix[2][0] | * | matrix[0][1] matrix[1][1] matrix[2][1] | * | matrix[0][2] matrix[1][2] matrix[2][2] | * | matrix[0][3] matrix[1][3] matrix[2][3] | * \ / * * @method getDeterminant * @param {Array} matrix An nxn matrix represented an array of vector (column) arrays. Each vector array has index for each row. * @return Number */ getDeterminant: function(matrix) { var determinant = 0, len = matrix.length, i = 0, multiplier; if(len == 2) { return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]; } for(; i < len; ++i) { multiplier = matrix[i][0]; if(i % 2 === 0 || i === 0) { determinant += multiplier * MatrixUtil.getDeterminant(MatrixUtil.getMinors(matrix, i, 0)); } else { determinant -= multiplier * MatrixUtil.getDeterminant(MatrixUtil.getMinors(matrix, i, 0)); } } return determinant; }, /** * Returns the inverse of a matrix * * @method inverse * @param Array matrix An array representing an nxn matrix * @return Array * * / \ * | matrix[0][0] matrix[1][0] matrix[2][0] | * | matrix[0][1] matrix[1][1] matrix[2][1] | * | matrix[0][2] matrix[1][2] matrix[2][2] | * | matrix[0][3] matrix[1][3] matrix[2][3] | * \ / */ inverse: function(matrix) { var determinant = 0, len = matrix.length, i = 0, j, inverse, adjunct = [], //vector representing 2x2 matrix minor = []; if(len === 2) { determinant = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0]; inverse = [ [matrix[1][1] * determinant, -matrix[1][0] * determinant], [-matrix[0][1] * determinant, matrix[0][0] * determinant] ]; } else { determinant = MatrixUtil.getDeterminant(matrix); for(; i < len; ++i) { adjunct[i] = []; for(j = 0; j < len; ++j) { minor = MatrixUtil.getMinors(matrix, j, i); adjunct[i][j] = MatrixUtil.getDeterminant(minor); if((i + j) % 2 !== 0 && (i + j) !== 0) { adjunct[i][j] *= -1; } } } inverse = MatrixUtil.scalarMultiply(adjunct, 1/determinant); } return inverse; }, /** * Multiplies a matrix by a numeric value. * * @method scalarMultiply * @param {Array} matrix The matrix to be altered. * @param {Number} multiplier The number to multiply against the matrix. * @return Array */ scalarMultiply: function(matrix, multiplier) { var i = 0, j, len = matrix.length; for(; i < len; ++i) { for(j = 0; j < len; ++j) { matrix[i][j] = MatrixUtil._round(matrix[i][j] * multiplier); } } return matrix; }, /** * Returns the transpose for an nxn matrix. * * @method transpose * @param matrix An nxn matrix represented by an array of vector arrays. * @return Array */ transpose: function(matrix) { var len = matrix.length, i = 0, j = 0, transpose = []; for(; i < len; ++i) { transpose[i] = []; for(j = 0; j < len; ++j) { transpose[i].push(matrix[j][i]); } } return transpose; }, /** * Returns a matrix of minors based on a matrix, column index and row index. * * @method getMinors * @param {Array} matrix The matrix from which to extract the matrix of minors. * @param {Number} columnIndex A zero-based index representing the specified column to exclude. * @param {Number} rowIndex A zero-based index represeenting the specified row to exclude. * @return Array */ getMinors: function(matrix, columnIndex, rowIndex) { var minors = [], len = matrix.length, i = 0, j, column; for(; i < len; ++i) { if(i !== columnIndex) { column = []; for(j = 0; j < len; ++j) { if(j !== rowIndex) { column.push(matrix[i][j]); } } minors.push(column); } } return minors; }, /** * Returns the sign of value * * @method sign * @param {Number} val value to be interpreted * @return Number */ sign: function(val) { return val === 0 ? 1 : val/Math.abs(val); }, /** * Multiplies a vector and a matrix * * @method vectorMatrixProduct * @param {Array} vector Array representing a column vector * @param {Array} matrix Array representing an nxn matrix * @return Array */ vectorMatrixProduct: function(vector, matrix) { var i, j, len = vector.length, product = [], rowProduct; for(i = 0; i < len; ++i) { rowProduct = 0; for(j = 0; j < len; ++j) { rowProduct += vector[i] * matrix[i][j]; } product[i] = rowProduct; } return product; }, /** * Breaks up a 2d transform matrix into a series of transform operations. * * @method decompose * @param {Array} matrix A 3x3 multidimensional array * @return Array */ decompose: function(matrix) { var a = parseFloat(matrix[0][0]), b = parseFloat(matrix[1][0]), c = parseFloat(matrix[0][1]), d = parseFloat(matrix[1][1]), dx = parseFloat(matrix[0][2]), dy = parseFloat(matrix[1][2]), rotate, sx, sy, shear; if((a * d - b * c) === 0) { return false; } //get length of vector(ab) sx = MatrixUtil._round(Math.sqrt(a * a + b * b)); //normalize components of vector(ab) a /= sx; b /= sx; shear = MatrixUtil._round(a * c + b * d); c -= a * shear; d -= b * shear; //get length of vector(cd) sy = MatrixUtil._round(Math.sqrt(c * c + d * d)); //normalize components of vector(cd) c /= sy; d /= sy; shear /=sy; shear = MatrixUtil._round(MatrixUtil.rad2deg(Math.atan(shear))); rotate = MatrixUtil._round(MatrixUtil.rad2deg(Math.atan2(matrix[1][0], matrix[0][0]))); return [ ["translate", dx, dy], ["rotate", rotate], ["skewX", shear], ["scale", sx, sy] ]; }, /** * Parses a transform string and returns an array of transform arrays. * * @method getTransformArray * @param {String} val A transform string * @return Array */ getTransformArray: function(transform) { var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi, transforms = [], args, m, decomp, methods = MatrixUtil.transformMethods; while ((m = re.exec(transform))) { if (methods.hasOwnProperty(m[1])) { args = m[2].split(','); args.unshift(m[1]); transforms.push(args); } else if(m[1] == "matrix") { args = m[2].split(','); decomp = MatrixUtil.decompose([ [args[0], args[2], args[4]], [args[1], args[3], args[5]], [0, 0, 1] ]); transforms.push(decomp[0]); transforms.push(decomp[1]); transforms.push(decomp[2]); transforms.push(decomp[3]); } } return transforms; }, /** * Returns an array of transform arrays representing transform functions and arguments. * * @method getTransformFunctionArray * @return Array */ getTransformFunctionArray: function(transform) { var list; switch(transform) { case "skew" : list = [transform, 0, 0]; break; case "scale" : list = [transform, 1, 1]; break; case "scaleX" : list = [transform, 1]; break; case "scaleY" : list = [transform, 1]; break; case "translate" : list = [transform, 0, 0]; break; default : list = [transform, 0]; break; } return list; }, /** * Compares to arrays or transform functions to ensure both contain the same functions in the same * order. * * @method compareTransformSequence * @param {Array} list1 Array to compare * @param {Array} list2 Array to compare * @return Boolean */ compareTransformSequence: function(list1, list2) { var i = 0, len = list1.length, len2 = list2.length, isEqual = len === len2; if(isEqual) { for(; i < len; ++i) { if(list1[i][0] != list2[i][0]) { isEqual = false; break; } } } return isEqual; }, /** * Mapping of possible transform method names. * * @property transformMethods * @type Object */ transformMethods: { rotate: "rotate", skew: "skew", skewX: "skewX", skewY: "skewY", translate: "translate", translateX: "translateX", translateY: "tranlsateY", scale: "scale", scaleX: "scaleX", scaleY: "scaleY" } }; Y.MatrixUtil = MatrixUtil; /** * Matrix is a class that allows for the manipulation of a transform matrix. * This class is a work in progress. * * @class Matrix * @constructor * @module matrix */ var Matrix = function(config) { this.init(config); }; Matrix.prototype = { /** * Used as value for the _rounding method. * * @property _rounder * @private */ _rounder: 100000, /** * Updates the matrix. * * @method multiple * @param {Number} a * @param {Number} b * @param {Number} c * @param {Number} d * @param {Number} dx * @param {Number} dy */ multiply: function(a, b, c, d, dx, dy) { var matrix = this, matrix_a = matrix.a * a + matrix.c * b, matrix_b = matrix.b * a + matrix.d * b, matrix_c = matrix.a * c + matrix.c * d, matrix_d = matrix.b * c + matrix.d * d, matrix_dx = matrix.a * dx + matrix.c * dy + matrix.dx, matrix_dy = matrix.b * dx + matrix.d * dy + matrix.dy; matrix.a = this._round(matrix_a); matrix.b = this._round(matrix_b); matrix.c = this._round(matrix_c); matrix.d = this._round(matrix_d); matrix.dx = this._round(matrix_dx); matrix.dy = this._round(matrix_dy); return this; }, /** * Parses a string and updates the matrix. * * @method applyCSSText * @param {String} val A css transform string */ applyCSSText: function(val) { var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi, args, m; val = val.replace(/matrix/g, "multiply"); while ((m = re.exec(val))) { if (typeof this[m[1]] === 'function') { args = m[2].split(','); this[m[1]].apply(this, args); } } }, /** * Parses a string and returns an array of transform arrays. * * @method getTransformArray * @param {String} val A css transform string * @return Array */ getTransformArray: function(val) { var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi, transforms = [], args, m; val = val.replace(/matrix/g, "multiply"); while ((m = re.exec(val))) { if (typeof this[m[1]] === 'function') { args = m[2].split(','); args.unshift(m[1]); transforms.push(args); } } return transforms; }, /** * Default values for the matrix * * @property _defaults * @private */ _defaults: { a: 1, b: 0, c: 0, d: 1, dx: 0, dy: 0 }, /** * Rounds values * * @method _round * @private */ _round: function(val) { val = Math.round(val * this._rounder) / this._rounder; return val; }, /** * Initializes a matrix. * * @method init * @param {Object} config Specified key value pairs for matrix properties. If a property is not explicitly defined in the config argument, * the default value will be used. */ init: function(config) { var defaults = this._defaults, prop; config = config || {}; for (prop in defaults) { if(defaults.hasOwnProperty(prop)) { this[prop] = (prop in config) ? config[prop] : defaults[prop]; } } this._config = config; }, /** * Applies a scale transform * * @method scale * @param {Number} val */ scale: function(x, y) { this.multiply(x, 0, 0, y, 0, 0); return this; }, /** * Applies a skew transformation. * * @method skew * @param {Number} x The value to skew on the x-axis. * @param {Number} y The value to skew on the y-axis. */ skew: function(x, y) { x = x || 0; y = y || 0; if (x !== undefined) { // null or undef x = Math.tan(this.angle2rad(x)); } if (y !== undefined) { // null or undef y = Math.tan(this.angle2rad(y)); } this.multiply(1, y, x, 1, 0, 0); return this; }, /** * Applies a skew to the x-coordinate * * @method skewX * @param {Number} x x-coordinate */ skewX: function(x) { this.skew(x); return this; }, /** * Applies a skew to the y-coordinate * * @method skewY * @param {Number} y y-coordinate */ skewY: function(y) { this.skew(null, y); return this; }, /** * Returns a string of text that can be used to populate a the css transform property of an element. * * @method toCSSText * @return String */ toCSSText: function() { var matrix = this, text = 'matrix(' + matrix.a + ',' + matrix.b + ',' + matrix.c + ',' + matrix.d + ',' + matrix.dx + ',' + matrix.dy + ')'; return text; }, /** * Returns a string that can be used to populate the css filter property of an element. * * @method toFilterText * @return String */ toFilterText: function() { var matrix = this, text = 'progid:DXImageTransform.Microsoft.Matrix('; text += 'M11=' + matrix.a + ',' + 'M21=' + matrix.b + ',' + 'M12=' + matrix.c + ',' + 'M22=' + matrix.d + ',' + 'sizingMethod="auto expand")'; text += ''; return text; }, /** * Converts a radian value to a degree. * * @method rad2deg * @param {Number} rad Radian value to be converted. * @return Number */ rad2deg: function(rad) { var deg = rad * (180 / Math.PI); return deg; }, /** * Converts a degree value to a radian. * * @method deg2rad * @param {Number} deg Degree value to be converted to radian. * @return Number */ deg2rad: function(deg) { var rad = deg * (Math.PI / 180); return rad; }, angle2rad: function(val) { if (typeof val === 'string' && val.indexOf('rad') > -1) { val = parseFloat(val); } else { // default to deg val = this.deg2rad(parseFloat(val)); } return val; }, /** * Applies a rotate transform. * * @method rotate * @param {Number} deg The degree of the rotation. */ rotate: function(deg, x, y) { var rad = this.angle2rad(deg), sin = Math.sin(rad), cos = Math.cos(rad); this.multiply(cos, sin, 0 - sin, cos, 0, 0); return this; }, /** * Applies translate transformation. * * @method translate * @param {Number} x The value to transate on the x-axis. * @param {Number} y The value to translate on the y-axis. */ translate: function(x, y) { x = parseFloat(x) || 0; y = parseFloat(y) || 0; this.multiply(1, 0, 0, 1, x, y); return this; }, /** * Applies a translate to the x-coordinate * * @method translateX * @param {Number} x x-coordinate */ translateX: function(x) { this.translate(x); return this; }, /** * Applies a translate to the y-coordinate * * @method translateY * @param {Number} y y-coordinate */ translateY: function(y) { this.translate(null, y); return this; }, /** * Returns an identity matrix. * * @method identity * @return Object */ identity: function() { var config = this._config, defaults = this._defaults, prop; for (prop in config) { if (prop in defaults) { this[prop] = defaults[prop]; } } return this; }, /** * Returns a 3x3 Matrix array * * / \ * | matrix[0][0] matrix[1][0] matrix[2][0] | * | matrix[0][1] matrix[1][1] matrix[2][1] | * | matrix[0][2] matrix[1][2] matrix[2][2] | * \ / * * @method getMatrixArray * @return Array */ getMatrixArray: function() { var matrix = this, matrixArray = [ [matrix.a, matrix.c, matrix.dx], [matrix.b, matrix.d, matrix.dy], [0, 0, 1] ]; return matrixArray; }, /** * Returns the left, top, right and bottom coordinates for a transformed * item. * * @method getContentRect * @param {Number} width The width of the item. * @param {Number} height The height of the item. * @param {Number} x The x-coordinate of the item. * @param {Number} y The y-coordinate of the item. * @return Object */ getContentRect: function(width, height, x, y) { var left = !isNaN(x) ? x : 0, top = !isNaN(y) ? y : 0, right = left + width, bottom = top + height, matrix = this, a = matrix.a, b = matrix.b, c = matrix.c, d = matrix.d, dx = matrix.dx, dy = matrix.dy, x1 = (a * left + c * top + dx), y1 = (b * left + d * top + dy), //[x2, y2] x2 = (a * right + c * top + dx), y2 = (b * right + d * top + dy), //[x3, y3] x3 = (a * left + c * bottom + dx), y3 = (b * left + d * bottom + dy), //[x4, y4] x4 = (a * right + c * bottom + dx), y4 = (b * right + d * bottom + dy); return { left: Math.min(x3, Math.min(x1, Math.min(x2, x4))), right: Math.max(x3, Math.max(x1, Math.max(x2, x4))), top: Math.min(y2, Math.min(y4, Math.min(y3, y1))), bottom: Math.max(y2, Math.max(y4, Math.max(y3, y1))) }; }, /** * Returns the determinant of the matrix. * * @method getDeterminant * @return Number */ getDeterminant: function() { return Y.MatrixUtil.getDeterminant(this.getMatrixArray()); }, /** * Returns the inverse (in array form) of the matrix. * * @method inverse * @return Array */ inverse: function() { return Y.MatrixUtil.inverse(this.getMatrixArray()); }, /** * Returns the transpose of the matrix * * @method transpose * @return Array */ transpose: function() { return Y.MatrixUtil.transpose(this.getMatrixArray()); }, /** * Returns an array of transform commands that represent the matrix. * * @method decompose * @return Array */ decompose: function() { return Y.MatrixUtil.decompose(this.getMatrixArray()); } }; Y.Matrix = Matrix; }, '3.17.2', {"requires": ["yui-base"]});