[Summary view] [Print] [Text view]

   1  /*
   2  YUI 3.17.2 (build 9c3c78e)
   3  Copyright 2014 Yahoo! Inc. All rights reserved.
   4  Licensed under the BSD License.
   5  http://yuilibrary.com/license/
   6  */
   7  
   8  YUI.add('matrix', function (Y, NAME) {
   9  
  10  /**
  11   * Matrix utilities.
  12   *
  13   * @class MatrixUtil
  14   * @module matrix
  15   **/
  16  
  17  var MatrixUtil = {
  18          /**
  19           * Used as value for the _rounding method.
  20           *
  21           * @property _rounder
  22           * @private
  23           */
  24          _rounder: 100000,
  25  
  26          /**
  27           * Rounds values
  28           *
  29           * @method _round
  30           * @private
  31           */
  32          _round: function(val) {
  33              val = Math.round(val * MatrixUtil._rounder) / MatrixUtil._rounder;
  34              return val;
  35          },
  36          /**
  37           * Converts a radian value to a degree.
  38           *
  39           * @method rad2deg
  40           * @param {Number} rad Radian value to be converted.
  41           * @return Number
  42           */
  43          rad2deg: function(rad) {
  44              var deg = rad * (180 / Math.PI);
  45              return deg;
  46          },
  47  
  48          /**
  49           * Converts a degree value to a radian.
  50           *
  51           * @method deg2rad
  52           * @param {Number} deg Degree value to be converted to radian.
  53           * @return Number
  54           */
  55          deg2rad: function(deg) {
  56              var rad = deg * (Math.PI / 180);
  57              return rad;
  58          },
  59  
  60          /**
  61           * Converts an angle to a radian
  62           *
  63           * @method angle2rad
  64           * @param {Objecxt} val Value to be converted to radian.
  65           * @return Number
  66           */
  67          angle2rad: function(val) {
  68              if (typeof val === 'string' && val.indexOf('rad') > -1) {
  69                  val = parseFloat(val);
  70              } else { // default to deg
  71                  val = MatrixUtil.deg2rad(parseFloat(val));
  72              }
  73  
  74              return val;
  75          },
  76  
  77          /**
  78           * Converts a transform object to an array of column vectors.
  79           *
  80           * /                                             \
  81           * | matrix[0][0]   matrix[1][0]    matrix[2][0] |
  82           * | matrix[0][1]   matrix[1][1]    matrix[2][1] |
  83           * | matrix[0][2]   matrix[1][2]    matrix[2][2] |
  84           * \                                             /
  85           *
  86           * @method getnxn
  87           * @return Array
  88           */
  89          convertTransformToArray: function(matrix)
  90          {
  91              var matrixArray = [
  92                      [matrix.a, matrix.c, matrix.dx],
  93                      [matrix.b, matrix.d, matrix.dy],
  94                      [0, 0, 1]
  95                  ];
  96              return matrixArray;
  97          },
  98  
  99          /**
 100           * Returns the determinant of a given matrix.
 101           *
 102           * /                                             \
 103           * | matrix[0][0]   matrix[1][0]    matrix[2][0] |
 104           * | matrix[0][1]   matrix[1][1]    matrix[2][1] |
 105           * | matrix[0][2]   matrix[1][2]    matrix[2][2] |
 106           * | matrix[0][3]   matrix[1][3]    matrix[2][3] |
 107           * \                                             /
 108           *
 109           * @method getDeterminant
 110           * @param {Array} matrix An nxn matrix represented an array of vector (column) arrays. Each vector array has index for each row.
 111           * @return Number
 112           */
 113          getDeterminant: function(matrix)
 114          {
 115              var determinant = 0,
 116                  len = matrix.length,
 117                  i = 0,
 118                  multiplier;
 119  
 120              if(len == 2)
 121              {
 122                  return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 123              }
 124              for(; i < len; ++i)
 125              {
 126                  multiplier = matrix[i][0];
 127                  if(i % 2 === 0 || i === 0)
 128                  {
 129                      determinant += multiplier * MatrixUtil.getDeterminant(MatrixUtil.getMinors(matrix, i, 0));
 130                  }
 131                  else
 132                  {
 133                      determinant -= multiplier * MatrixUtil.getDeterminant(MatrixUtil.getMinors(matrix, i, 0));
 134                  }
 135              }
 136              return determinant;
 137          },
 138  
 139          /**
 140           * Returns the inverse of a matrix
 141           *
 142           * @method inverse
 143           * @param Array matrix An array representing an nxn matrix
 144           * @return Array
 145           *
 146           * /                                             \
 147           * | matrix[0][0]   matrix[1][0]    matrix[2][0] |
 148           * | matrix[0][1]   matrix[1][1]    matrix[2][1] |
 149           * | matrix[0][2]   matrix[1][2]    matrix[2][2] |
 150           * | matrix[0][3]   matrix[1][3]    matrix[2][3] |
 151           * \                                             /
 152           */
 153          inverse: function(matrix)
 154          {
 155              var determinant = 0,
 156                  len = matrix.length,
 157                  i = 0,
 158                  j,
 159                  inverse,
 160                  adjunct = [],
 161                  //vector representing 2x2 matrix
 162                  minor = [];
 163              if(len === 2)
 164              {
 165                  determinant = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
 166                  inverse = [
 167                      [matrix[1][1] * determinant, -matrix[1][0] * determinant],
 168                      [-matrix[0][1] * determinant, matrix[0][0] * determinant]
 169                  ];
 170              }
 171              else
 172              {
 173                  determinant = MatrixUtil.getDeterminant(matrix);
 174                  for(; i < len; ++i)
 175                  {
 176                      adjunct[i] = [];
 177                      for(j = 0; j < len; ++j)
 178                      {
 179                          minor = MatrixUtil.getMinors(matrix, j, i);
 180                          adjunct[i][j] = MatrixUtil.getDeterminant(minor);
 181                          if((i + j) % 2 !== 0 && (i + j) !== 0)
 182                          {
 183                              adjunct[i][j] *= -1;
 184                          }
 185                      }
 186                  }
 187                  inverse = MatrixUtil.scalarMultiply(adjunct, 1/determinant);
 188              }
 189              return inverse;
 190          },
 191  
 192          /**
 193           * Multiplies a matrix by a numeric value.
 194           *
 195           * @method scalarMultiply
 196           * @param {Array} matrix The matrix to be altered.
 197           * @param {Number} multiplier The number to multiply against the matrix.
 198           * @return Array
 199           */
 200          scalarMultiply: function(matrix, multiplier)
 201          {
 202              var i = 0,
 203                  j,
 204                  len = matrix.length;
 205              for(; i < len; ++i)
 206              {
 207                  for(j = 0; j < len; ++j)
 208                  {
 209                      matrix[i][j] = MatrixUtil._round(matrix[i][j] * multiplier);
 210                  }
 211              }
 212              return matrix;
 213          },
 214  
 215          /**
 216           * Returns the transpose for an nxn matrix.
 217           *
 218           * @method transpose
 219           * @param matrix An nxn matrix represented by an array of vector arrays.
 220           * @return Array
 221           */
 222          transpose: function(matrix)
 223          {
 224              var len = matrix.length,
 225                  i = 0,
 226                  j = 0,
 227                  transpose = [];
 228              for(; i < len; ++i)
 229              {
 230                  transpose[i] = [];
 231                  for(j = 0; j < len; ++j)
 232                  {
 233                      transpose[i].push(matrix[j][i]);
 234                  }
 235              }
 236              return transpose;
 237          },
 238  
 239          /**
 240           * Returns a matrix of minors based on a matrix, column index and row index.
 241           *
 242           * @method getMinors
 243           * @param {Array} matrix The matrix from which to extract the matrix of minors.
 244           * @param {Number} columnIndex A zero-based index representing the specified column to exclude.
 245           * @param {Number} rowIndex A zero-based index represeenting the specified row to exclude.
 246           * @return Array
 247           */
 248          getMinors: function(matrix, columnIndex, rowIndex)
 249          {
 250              var minors = [],
 251                  len = matrix.length,
 252                  i = 0,
 253                  j,
 254                  column;
 255              for(; i < len; ++i)
 256              {
 257                  if(i !== columnIndex)
 258                  {
 259                      column = [];
 260                      for(j = 0; j < len; ++j)
 261                      {
 262                          if(j !== rowIndex)
 263                          {
 264                              column.push(matrix[i][j]);
 265                          }
 266                      }
 267                      minors.push(column);
 268                  }
 269              }
 270              return minors;
 271          },
 272  
 273          /**
 274           * Returns the sign of value
 275           *
 276           * @method sign
 277           * @param {Number} val value to be interpreted
 278           * @return Number
 279           */
 280          sign: function(val)
 281          {
 282              return val === 0 ? 1 : val/Math.abs(val);
 283          },
 284  
 285          /**
 286           * Multiplies a vector and a matrix
 287           *
 288           * @method vectorMatrixProduct
 289           * @param {Array} vector Array representing a column vector
 290           * @param {Array} matrix Array representing an nxn matrix
 291           * @return Array
 292           */
 293          vectorMatrixProduct: function(vector, matrix)
 294          {
 295              var i,
 296                  j,
 297                  len = vector.length,
 298                  product = [],
 299                  rowProduct;
 300              for(i = 0; i < len; ++i)
 301              {
 302                  rowProduct = 0;
 303                  for(j = 0; j < len; ++j)
 304                  {
 305                      rowProduct += vector[i] * matrix[i][j];
 306                  }
 307                  product[i] = rowProduct;
 308              }
 309              return product;
 310          },
 311  
 312          /**
 313           * Breaks up a 2d transform matrix into a series of transform operations.
 314           *
 315           * @method decompose
 316           * @param {Array} matrix A 3x3 multidimensional array
 317           * @return Array
 318           */
 319          decompose: function(matrix)
 320          {
 321              var a = parseFloat(matrix[0][0]),
 322                  b = parseFloat(matrix[1][0]),
 323                  c = parseFloat(matrix[0][1]),
 324                  d = parseFloat(matrix[1][1]),
 325                  dx = parseFloat(matrix[0][2]),
 326                  dy = parseFloat(matrix[1][2]),
 327                  rotate,
 328                  sx,
 329                  sy,
 330                  shear;
 331              if((a * d - b * c) === 0)
 332              {
 333                  return false;
 334              }
 335              //get length of vector(ab)
 336              sx = MatrixUtil._round(Math.sqrt(a * a + b * b));
 337              //normalize components of vector(ab)
 338              a /= sx;
 339              b /= sx;
 340              shear = MatrixUtil._round(a * c + b * d);
 341              c -= a * shear;
 342              d -= b * shear;
 343              //get length of vector(cd)
 344              sy = MatrixUtil._round(Math.sqrt(c * c + d * d));
 345              //normalize components of vector(cd)
 346              c /= sy;
 347              d /= sy;
 348              shear /=sy;
 349              shear = MatrixUtil._round(MatrixUtil.rad2deg(Math.atan(shear)));
 350              rotate = MatrixUtil._round(MatrixUtil.rad2deg(Math.atan2(matrix[1][0], matrix[0][0])));
 351  
 352              return [
 353                  ["translate", dx, dy],
 354                  ["rotate", rotate],
 355                  ["skewX", shear],
 356                  ["scale", sx, sy]
 357              ];
 358          },
 359  
 360          /**
 361           * Parses a transform string and returns an array of transform arrays.
 362           *
 363           * @method getTransformArray
 364           * @param {String} val A transform string
 365           * @return Array
 366           */
 367          getTransformArray: function(transform) {
 368              var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi,
 369                  transforms = [],
 370                  args,
 371                  m,
 372                  decomp,
 373                  methods = MatrixUtil.transformMethods;
 374  
 375              while ((m = re.exec(transform))) {
 376                  if (methods.hasOwnProperty(m[1]))
 377                  {
 378                      args = m[2].split(',');
 379                      args.unshift(m[1]);
 380                      transforms.push(args);
 381                  }
 382                  else if(m[1] == "matrix")
 383                  {
 384                      args = m[2].split(',');
 385                      decomp = MatrixUtil.decompose([
 386                          [args[0], args[2], args[4]],
 387                          [args[1], args[3], args[5]],
 388                          [0, 0, 1]
 389                      ]);
 390                      transforms.push(decomp[0]);
 391                      transforms.push(decomp[1]);
 392                      transforms.push(decomp[2]);
 393                      transforms.push(decomp[3]);
 394                  }
 395              }
 396              return transforms;
 397          },
 398  
 399          /**
 400           * Returns an array of transform arrays representing transform functions and arguments.
 401           *
 402           * @method getTransformFunctionArray
 403           * @return Array
 404           */
 405          getTransformFunctionArray: function(transform) {
 406              var list;
 407              switch(transform)
 408              {
 409                  case "skew" :
 410                      list = [transform, 0, 0];
 411                  break;
 412                  case "scale" :
 413                      list = [transform, 1, 1];
 414                  break;
 415                  case "scaleX" :
 416                      list = [transform, 1];
 417                  break;
 418                  case "scaleY" :
 419                      list = [transform, 1];
 420                  break;
 421                  case "translate" :
 422                      list = [transform, 0, 0];
 423                  break;
 424                  default :
 425                      list = [transform, 0];
 426                  break;
 427              }
 428              return list;
 429          },
 430  
 431          /**
 432           * Compares to arrays or transform functions to ensure both contain the same functions in the same
 433           * order.
 434           *
 435           * @method compareTransformSequence
 436           * @param {Array} list1 Array to compare
 437           * @param {Array} list2 Array to compare
 438           * @return Boolean
 439           */
 440          compareTransformSequence: function(list1, list2)
 441          {
 442              var i = 0,
 443                  len = list1.length,
 444                  len2 = list2.length,
 445                  isEqual = len === len2;
 446              if(isEqual)
 447              {
 448                  for(; i < len; ++i)
 449                  {
 450                      if(list1[i][0] != list2[i][0])
 451                      {
 452                          isEqual = false;
 453                          break;
 454                      }
 455                  }
 456              }
 457              return isEqual;
 458          },
 459  
 460          /**
 461           * Mapping of possible transform method names.
 462           *
 463           * @property transformMethods
 464           * @type Object
 465           */
 466          transformMethods: {
 467              rotate: "rotate",
 468              skew: "skew",
 469              skewX: "skewX",
 470              skewY: "skewY",
 471              translate: "translate",
 472              translateX: "translateX",
 473              translateY: "tranlsateY",
 474              scale: "scale",
 475              scaleX: "scaleX",
 476              scaleY: "scaleY"
 477          }
 478  
 479  };
 480  
 481  Y.MatrixUtil = MatrixUtil;
 482  
 483  /**
 484   * Matrix is a class that allows for the manipulation of a transform matrix.
 485   * This class is a work in progress.
 486   *
 487   * @class Matrix
 488   * @constructor
 489   * @module matrix
 490   */
 491  var Matrix = function(config) {
 492      this.init(config);
 493  };
 494  
 495  Matrix.prototype = {
 496      /**
 497       * Used as value for the _rounding method.
 498       *
 499       * @property _rounder
 500       * @private
 501       */
 502      _rounder: 100000,
 503  
 504      /**
 505       * Updates the matrix.
 506       *
 507       * @method multiple
 508       * @param {Number} a
 509       * @param {Number} b
 510       * @param {Number} c
 511       * @param {Number} d
 512       * @param {Number} dx
 513       * @param {Number} dy
 514       */
 515      multiply: function(a, b, c, d, dx, dy) {
 516          var matrix = this,
 517              matrix_a = matrix.a * a + matrix.c * b,
 518              matrix_b = matrix.b * a + matrix.d * b,
 519              matrix_c = matrix.a * c + matrix.c * d,
 520              matrix_d = matrix.b * c + matrix.d * d,
 521              matrix_dx = matrix.a * dx + matrix.c * dy + matrix.dx,
 522              matrix_dy = matrix.b * dx + matrix.d * dy + matrix.dy;
 523  
 524          matrix.a = this._round(matrix_a);
 525          matrix.b = this._round(matrix_b);
 526          matrix.c = this._round(matrix_c);
 527          matrix.d = this._round(matrix_d);
 528          matrix.dx = this._round(matrix_dx);
 529          matrix.dy = this._round(matrix_dy);
 530          return this;
 531      },
 532  
 533      /**
 534       * Parses a string and updates the matrix.
 535       *
 536       * @method applyCSSText
 537       * @param {String} val A css transform string
 538       */
 539      applyCSSText: function(val) {
 540          var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi,
 541              args,
 542              m;
 543  
 544          val = val.replace(/matrix/g, "multiply");
 545          while ((m = re.exec(val))) {
 546              if (typeof this[m[1]] === 'function') {
 547                  args = m[2].split(',');
 548                  this[m[1]].apply(this, args);
 549              }
 550          }
 551      },
 552  
 553      /**
 554       * Parses a string and returns an array of transform arrays.
 555       *
 556       * @method getTransformArray
 557       * @param {String} val A css transform string
 558       * @return Array
 559       */
 560      getTransformArray: function(val) {
 561          var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi,
 562              transforms = [],
 563              args,
 564              m;
 565  
 566          val = val.replace(/matrix/g, "multiply");
 567          while ((m = re.exec(val))) {
 568              if (typeof this[m[1]] === 'function') {
 569                  args = m[2].split(',');
 570                  args.unshift(m[1]);
 571                  transforms.push(args);
 572              }
 573          }
 574          return transforms;
 575      },
 576  
 577      /**
 578       * Default values for the matrix
 579       *
 580       * @property _defaults
 581       * @private
 582       */
 583      _defaults: {
 584          a: 1,
 585          b: 0,
 586          c: 0,
 587          d: 1,
 588          dx: 0,
 589          dy: 0
 590      },
 591  
 592      /**
 593       * Rounds values
 594       *
 595       * @method _round
 596       * @private
 597       */
 598      _round: function(val) {
 599          val = Math.round(val * this._rounder) / this._rounder;
 600          return val;
 601      },
 602  
 603      /**
 604       * Initializes a matrix.
 605       *
 606       * @method init
 607       * @param {Object} config Specified key value pairs for matrix properties. If a property is not explicitly defined in the config argument,
 608       * the default value will be used.
 609       */
 610      init: function(config) {
 611          var defaults = this._defaults,
 612              prop;
 613  
 614          config = config || {};
 615  
 616          for (prop in defaults) {
 617              if(defaults.hasOwnProperty(prop))
 618              {
 619                  this[prop] = (prop in config) ? config[prop] : defaults[prop];
 620              }
 621          }
 622  
 623          this._config = config;
 624      },
 625  
 626      /**
 627       * Applies a scale transform
 628       *
 629       * @method scale
 630       * @param {Number} val
 631       */
 632      scale: function(x, y) {
 633          this.multiply(x, 0, 0, y, 0, 0);
 634          return this;
 635      },
 636  
 637      /**
 638       * Applies a skew transformation.
 639       *
 640       * @method skew
 641       * @param {Number} x The value to skew on the x-axis.
 642       * @param {Number} y The value to skew on the y-axis.
 643       */
 644      skew: function(x, y) {
 645          x = x || 0;
 646          y = y || 0;
 647  
 648          if (x !== undefined) { // null or undef
 649              x = Math.tan(this.angle2rad(x));
 650  
 651          }
 652  
 653          if (y !== undefined) { // null or undef
 654              y = Math.tan(this.angle2rad(y));
 655          }
 656  
 657          this.multiply(1, y, x, 1, 0, 0);
 658          return this;
 659      },
 660  
 661      /**
 662       * Applies a skew to the x-coordinate
 663       *
 664       * @method skewX
 665       * @param {Number} x x-coordinate
 666       */
 667      skewX: function(x) {
 668          this.skew(x);
 669          return this;
 670      },
 671  
 672      /**
 673       * Applies a skew to the y-coordinate
 674       *
 675       * @method skewY
 676       * @param {Number} y y-coordinate
 677       */
 678      skewY: function(y) {
 679          this.skew(null, y);
 680          return this;
 681      },
 682  
 683      /**
 684       * Returns a string of text that can be used to populate a the css transform property of an element.
 685       *
 686       * @method toCSSText
 687       * @return String
 688       */
 689      toCSSText: function() {
 690          var matrix = this,
 691              text = 'matrix(' +
 692                      matrix.a + ',' +
 693                      matrix.b + ',' +
 694                      matrix.c + ',' +
 695                      matrix.d + ',' +
 696                      matrix.dx + ',' +
 697                      matrix.dy + ')';
 698          return text;
 699      },
 700  
 701      /**
 702       * Returns a string that can be used to populate the css filter property of an element.
 703       *
 704       * @method toFilterText
 705       * @return String
 706       */
 707      toFilterText: function() {
 708          var matrix = this,
 709              text = 'progid:DXImageTransform.Microsoft.Matrix(';
 710          text +=     'M11=' + matrix.a + ',' +
 711                      'M21=' + matrix.b + ',' +
 712                      'M12=' + matrix.c + ',' +
 713                      'M22=' + matrix.d + ',' +
 714                      'sizingMethod="auto expand")';
 715  
 716          text += '';
 717  
 718          return text;
 719      },
 720  
 721      /**
 722       * Converts a radian value to a degree.
 723       *
 724       * @method rad2deg
 725       * @param {Number} rad Radian value to be converted.
 726       * @return Number
 727       */
 728      rad2deg: function(rad) {
 729          var deg = rad * (180 / Math.PI);
 730          return deg;
 731      },
 732  
 733      /**
 734       * Converts a degree value to a radian.
 735       *
 736       * @method deg2rad
 737       * @param {Number} deg Degree value to be converted to radian.
 738       * @return Number
 739       */
 740      deg2rad: function(deg) {
 741          var rad = deg * (Math.PI / 180);
 742          return rad;
 743      },
 744  
 745      angle2rad: function(val) {
 746          if (typeof val === 'string' && val.indexOf('rad') > -1) {
 747              val = parseFloat(val);
 748          } else { // default to deg
 749              val = this.deg2rad(parseFloat(val));
 750          }
 751  
 752          return val;
 753      },
 754  
 755      /**
 756       * Applies a rotate transform.
 757       *
 758       * @method rotate
 759       * @param {Number} deg The degree of the rotation.
 760       */
 761      rotate: function(deg, x, y) {
 762          var rad = this.angle2rad(deg),
 763              sin = Math.sin(rad),
 764              cos = Math.cos(rad);
 765          this.multiply(cos, sin, 0 - sin, cos, 0, 0);
 766          return this;
 767      },
 768  
 769      /**
 770       * Applies translate transformation.
 771       *
 772       * @method translate
 773       * @param {Number} x The value to transate on the x-axis.
 774       * @param {Number} y The value to translate on the y-axis.
 775       */
 776      translate: function(x, y) {
 777          x = parseFloat(x) || 0;
 778          y = parseFloat(y) || 0;
 779          this.multiply(1, 0, 0, 1, x, y);
 780          return this;
 781      },
 782  
 783      /**
 784       * Applies a translate to the x-coordinate
 785       *
 786       * @method translateX
 787       * @param {Number} x x-coordinate
 788       */
 789      translateX: function(x) {
 790          this.translate(x);
 791          return this;
 792      },
 793  
 794      /**
 795       * Applies a translate to the y-coordinate
 796       *
 797       * @method translateY
 798       * @param {Number} y y-coordinate
 799       */
 800      translateY: function(y) {
 801          this.translate(null, y);
 802          return this;
 803      },
 804  
 805  
 806      /**
 807       * Returns an identity matrix.
 808       *
 809       * @method identity
 810       * @return Object
 811       */
 812      identity: function() {
 813          var config = this._config,
 814              defaults = this._defaults,
 815              prop;
 816  
 817          for (prop in config) {
 818              if (prop in defaults) {
 819                  this[prop] = defaults[prop];
 820              }
 821          }
 822          return this;
 823      },
 824  
 825      /**
 826       * Returns a 3x3 Matrix array
 827       *
 828       * /                                             \
 829       * | matrix[0][0]   matrix[1][0]    matrix[2][0] |
 830       * | matrix[0][1]   matrix[1][1]    matrix[2][1] |
 831       * | matrix[0][2]   matrix[1][2]    matrix[2][2] |
 832       * \                                             /
 833       *
 834       * @method getMatrixArray
 835       * @return Array
 836       */
 837      getMatrixArray: function()
 838      {
 839          var matrix = this,
 840              matrixArray = [
 841                  [matrix.a, matrix.c, matrix.dx],
 842                  [matrix.b, matrix.d, matrix.dy],
 843                  [0, 0, 1]
 844              ];
 845          return matrixArray;
 846      },
 847  
 848      /**
 849       * Returns the left, top, right and bottom coordinates for a transformed
 850       * item.
 851       *
 852       * @method getContentRect
 853       * @param {Number} width The width of the item.
 854       * @param {Number} height The height of the item.
 855       * @param {Number} x The x-coordinate of the item.
 856       * @param {Number} y The y-coordinate of the item.
 857       * @return Object
 858       */
 859      getContentRect: function(width, height, x, y)
 860      {
 861          var left = !isNaN(x) ? x : 0,
 862              top = !isNaN(y) ? y : 0,
 863              right = left + width,
 864              bottom = top + height,
 865              matrix = this,
 866              a = matrix.a,
 867              b = matrix.b,
 868              c = matrix.c,
 869              d = matrix.d,
 870              dx = matrix.dx,
 871              dy = matrix.dy,
 872              x1 = (a * left + c * top + dx),
 873              y1 = (b * left + d * top + dy),
 874              //[x2, y2]
 875              x2 = (a * right + c * top + dx),
 876              y2 = (b * right + d * top + dy),
 877              //[x3, y3]
 878              x3 = (a * left + c * bottom + dx),
 879              y3 = (b * left + d * bottom + dy),
 880              //[x4, y4]
 881              x4 = (a * right + c * bottom + dx),
 882              y4 = (b * right + d * bottom + dy);
 883          return {
 884              left: Math.min(x3, Math.min(x1, Math.min(x2, x4))),
 885              right: Math.max(x3, Math.max(x1, Math.max(x2, x4))),
 886              top: Math.min(y2, Math.min(y4, Math.min(y3, y1))),
 887              bottom: Math.max(y2, Math.max(y4, Math.max(y3, y1)))
 888          };
 889      },
 890  
 891      /**
 892       * Returns the determinant of the matrix.
 893       *
 894       * @method getDeterminant
 895       * @return Number
 896       */
 897      getDeterminant: function()
 898      {
 899          return Y.MatrixUtil.getDeterminant(this.getMatrixArray());
 900      },
 901  
 902      /**
 903       * Returns the inverse (in array form) of the matrix.
 904       *
 905       * @method inverse
 906       * @return Array
 907       */
 908      inverse: function()
 909      {
 910          return Y.MatrixUtil.inverse(this.getMatrixArray());
 911      },
 912  
 913      /**
 914       * Returns the transpose of the matrix
 915       *
 916       * @method transpose
 917       * @return Array
 918       */
 919      transpose: function()
 920      {
 921          return Y.MatrixUtil.transpose(this.getMatrixArray());
 922      },
 923  
 924      /**
 925       * Returns an array of transform commands that represent the matrix.
 926       *
 927       * @method decompose
 928       * @return Array
 929       */
 930      decompose: function()
 931      {
 932          return Y.MatrixUtil.decompose(this.getMatrixArray());
 933      }
 934  };
 935  
 936  Y.Matrix = Matrix;
 937  
 938  
 939  }, '3.17.2', {"requires": ["yui-base"]});