In-depth analysis of the method of controlling graphics matrix transformation in HTML5 Canvas_html5 tutorial skills

Before introducing matrix transformation transform(), let’s talk about what a transformation matrix is.

The above is the transformation matrix corresponding to the transform() method in Canvas. This method passes in the six parameters shown in the figure, specifically context.transform(a,b,c,d,e,f).

The meaning of each parameter corresponds to the following table:

参数	意义
a	水平缩放（1）
b	水平倾斜（0）
c	垂直倾斜（0）
d	垂直缩放（1）
e	水平位移（0）
f	垂直位移（0）

When we substitute the corresponding 0 or 1 into the matrix, we can find that this is an identity matrix (the default value of horizontal and vertical scaling is 1, which means scaling by 1 times, that is, no scaling). This method uses a new change matrix to multiply the current transformation matrix, and then obtains various change effects.

To put it simply, when we want to transform a graphic, we only need to operate the corresponding parameters of the transformation matrix. After the operation, multiply the coordinates of each fixed point of the graphic by this matrix to get a new The coordinates of the fixed point.

transform() method

Canvas drawing provides us with a method to change this transformation matrix, that is transform().

The default coordinate system is based on the upper left corner of the canvas as the coordinate origin (0, 0). The further to the right the X-axis value is, the greater the value is, and the further down the Y-axis value is the greater it is. In the default coordinate system, the coordinates of each point are directly mapped to a CSS pixel. Some specific operations and property settings on the canvas use the default coordinate system. However, in addition to the default coordinate system, each canvas also has a "current transformation matrix" as part of the graphics state. This matrix defines the current coordinate system of the canvas. When the coordinates of a point are specified, most operations on the canvas map the point to the current coordinate system, rather than the default coordinate system. The current transformation matrix is ​​used to transform the specified coordinates into equivalent coordinates in the default coordinate system. The transformation of coordinates also affects the drawing of text and line segments.

Calling the translate() method simply moves the coordinate origin up, down, left, and right. The
rotate() method will rotate the coordinate axis clockwise according to the specified angle.
The scale() method implements extending and shortening the distance on the x-axis or the y-axis. Passing a negative value will achieve

scale to flip the coordinate axis using the coordinate origin as the reference point. Like a reflection in a mirror.
translate is used to move the coordinate origin to the lower left corner of the canvas, and then the scale method is used to flip the y-axis, so that the y-axis becomes larger as it goes up.

Understand coordinate system transformation from a mathematical perspective:
The translate, rotate and scale methods are easy to understand if you imagine them as transformations of the coordinate axes. It is easy to understand coordinate transformation from an algebraic perspective, that is, imagine the transformation as a point (x, y) in the transformed coordinate system, and the original coordinate system becomes (x`, y`).
Call c.translate(dx,dy). The method is equivalent to the following expression

Copy code

The code is as follows:

x` = x dx; //new The 0 of the x-axis in the system is dx
y` = y dy;
c.scale(sx,sy);
x` = sx*x;
y` = in the original system sy*y;
c.rotate()
x` =x*cos(a)-y*sin(a);
y` = y*cos(a) x*sin(a) ;

It is recommended to use transform() in the following situations:

1. Use context.transform (1,0,0,1,dx,dy) instead of context.translate(dx,dy)
2. Use context.transform(sx,0,0,sy,0 ,0) instead of context.scale(sx, sy)
3. Use context.transform(0,b,c,0,0,0) to achieve the tilt effect (the most practical).
There is no need to use it to achieve rotation. In addition, there is no need to remember all these conclusions. Just write down the meaning of the six parameters of abcdef. The effect is the same.

Let’s look at a code to get familiar with it:

JavaScript CodeCopy content to clipboard

1. nbsp;html>   
2. "zh">   
3.   
4.      "UTF-8">   
5.        
6.     
7.         body { background: url("./images/bg3.jpg") repeat; }  
8.         #canvas { border: 1px solid #aaaaaa; display: block; margin: 50px auto; }   
9.        
10.   
11.   
12. "canvas-warp">   
13.     "canvas">   
14.         你的浏览器居然不支持Canvas？！赶快换一个吧！！   
15.        

  

  

<script>   </script>

    window.onload = function(){   

        var canvas = document.getElementById("canvas");   

        canvas.width = 800;   

        canvas.height = 600;   

        var context = canvas.getContext("2d");   

        context.fillStyle = "#FFF";   

        context.fillRect(0,0,800,600);   

  

        context.fillStyle = "yellow";   

        context.strokeStyle = "#00AAAA";   

        context.lineWidth = 5;   

  

        context.save();   

        //平移至(300,200)   

        context.transform(1,0,0,1,300,200);   

        //水平方向放大2倍，垂直方向放大1.5倍   

        context.transform(2,0,0,1.5,0,0);   

        //水平方向向右倾斜宽度10%的距离，垂直方向向上倾斜高度10%的距离   

        context.transform(1,-0.1,0.1,1,0,0);   

        context.fillRect(0,0,200,200);   

        context.strokeRect(0,0,200,200);   

        context.restore();   

    };