dojox/gfx/decompose.js

  • Provides:

    • dojox.gfx.decompose

  • Requires:

    • dojox.gfx.matrix in common

  • m1

    • summary
  • b
       
    • summary
  • c
       
    • summary
  • d
       
    • summary
  • l1
       
    • summary
  • l2
       
    • summary
  • vx1
       
    • summary
  • vx2
       
    • summary
  • d2
       
    • summary
  • vy1
       
    • summary
  • vy2
       
    • summary
  • a
       
    • summary
  • cos
       
    • summary
  • result.sx
       
    • summary
  • result.sy
       
    • summary
  • dojox.gfx.decompose
       
    • type
      Function
    • parameters: 
      • matrix: (typeof dojox.gfx.matrix.Matrix2D)
        a 2D matrix-like object
    • source: [view] 
                    
      

                      var M = m.normalize(matrix),
         result = {dx: M.dx, dy: M.dy, sx: 1, sy: 1, angle1: 0, angle2: 0};
        // detect case: [scale]
        if(eq(M.xy, 0) && eq(M.yx, 0)){
         return dojo.mixin(result, {sx: M.xx, sy: M.yy}); // Object
        }
        // detect case: [scale, rotate]
        if(eq(M.xx * M.yx, -M.xy * M.yy)){
         return decomposeSR(M, result); // Object
        }
        // detect case: [rotate, scale]
        if(eq(M.xx * M.xy, -M.yx * M.yy)){
         return decomposeRS(M, result); // Object
        }
        // do SVD
        var MT = transpose(M),
         u  = eigenvalueDecomposition([M, MT]),
         v  = eigenvalueDecomposition([MT, M]),
         U  = new m.Matrix2D({xx: u.vector1.x, xy: u.vector2.x, yx: u.vector1.y, yy: u.vector2.y}),
         VT = new m.Matrix2D({xx: v.vector1.x, xy: v.vector1.y, yx: v.vector2.x, yy: v.vector2.y}),
         S = new m.Matrix2D([m.invert(U), M, m.invert(VT)]);
        decomposeSR(VT, result);
        S.xx *= result.sx;
        S.yy *= result.sy;
        decomposeRS(U, result);
        S.xx *= result.sx;
        S.yy *= result.sy;
        return dojo.mixin(result, {sx: S.xx, sy: S.yy}); // Object
                    
      
                    
    • summary
      decompose a 2D matrix into translation, scaling, and rotation components
    • description
      this function decompose a matrix into four logical components:
translation, rotation, scaling, and one more rotation using SVD.
The components should be applied in following order:

 [translate, rotate(angle2), scale, rotate(angle1)]
    • returns
      Object
  • result.dx
       
    • summary
  • result.dy
       
    • summary
  • result.angle1
       
    • summary
  • result.angle2
       
    • summary
  • result
       
    • type
      Object
    • summary
  • dojox.gfx
       
    • type
      Object
    • summary
  • dojox
       
    • type
      Object
    • summary