HTML5 Canvas - Zooming into a Point

Question

So I know there are threads about it already here, like that one. I followed the idea that was proposed in the thread above, and it works. However, I don't understand WHY it works.

Here is an example:

Let's say that i have a square centered at (100, 100), and its width/height is 100. So its top-left corner will be at (50, 50).

Now let's say that i want to zoom X2 into the square's center, that is, to zoom into (100, 100). So i will write the following transformation sequence:

translate(100, 100);
scale(2, 2);
translate(-100, -100);

So because the canvas apply the transformation in reverse order, my transformed square's top-left corner will be now at (0, 0), and its height/width will be 200.

Ok, let's say that now i want to zoom X2 into the right-bottom corner of the already transformed square. So intuitively, i would like to perform the following transformation sequence:

translate(200, 200);
scale(2, 2);
translate(-200, -200);

But it wont work, because again, the canvas apply transfomations in reverse order. That is to say, that if i sum up my two transformation sequences, i'll get:

// First Sequence
translate(100, 100);
scale(2, 2);
translate(-100, -100);

// Second Sequence
translate(200, 200);
scale(2, 2);
translate(-200, -200);

This means that the second sequence will be applied to each point before the first sequence (because the canvas will apply the transformation from bottom to top), and this is wrong. So as the thread in the link above suggest the following:

Because sequence 2 will be applied first, i should transform the point (200, 200) to its original coordinates, by applying to it the inverse of the first sequence. that is to say, if T1 is the matrix that represents the first sequence, then it will look like that:

// First Sequence
translate(100, 100);
scale(2, 2);
translate(-100, -100);

// Second Sequence
var point = SVGPoint(200, 200);
var transformedPoint = point.matrixTransform(T1.inverse());
translate(-transformedPoint.x, -transformedPoint.y);
scale(2, 2);
translate(transformedPoint.x, transformedPoint.y);

But why it works? I really don't understand why it should work like that... can anyone elaborate about it?

Thanks!

Answer 1

The HTML5 canvas transformations happen top-down, not bottom-up as you believe. The reason for the distinction is because the transformations applied to the canvas affect the coordinate system, not your logical coordinates.

Translating by translate(100, 100) will move your coordinate system right and down, which appears hauntingly similar to moving your logical coordinate up and left.

Let's take the first sequence (I have changed your use of transform to translate):

translate(100, 100);
scale(2, 2);
translate(-100, -100);

Naturally, when we think to scale an object from it's center, we translate the object to (0,0), scale the object, then move the object back. The above code, when read in reverse, would appear to do that. However, that's not the case.

When we read the above code from top-down, it says (assume we start with an identity transform):

1. Move the context's (0,0) right 100 units and down 100 units. This takes it to the canvas's (100,100) location.
2. Make the coordinate system 2x bigger.
3. Move the context's (0,0) left 100 units and up 100 units, essentially returning it to it's original location (in context coordinate space, not canvas space).

The scaling happens relative to the context's (0,0) point, which is at (100,100) on the canvas.

If we were to now add your second sequence:

translate(200, 200);
scale(2, 2);
translate(-200, -200);

This will:

1. Move the context's (0,0) to the coordinate system's (200,200) location.
2. Make the coordinate system 2x bigger than it already was.
3. Return the context's (0,0) back to where it was previously (in context coordinate space, not canvas space).

As you've found out, that does not give you what you are expecting because (200,200) is not the point about which you want to scale. Remember, all units are relative to the context coordinate system. So we need to convert the canvas location of (200,200) to the context coordinate location of (150,150) which is the original bottom-right corner of our rectangle.

So we change sequence #2 to be:

translate(150, 150);
scale(2, 2);
translate(-150, -150);

This gives us what we are expecting (to zoom in on the bottom-right corner of the rectangle). That's why we do the inverse-transform.

In the demo application, when the app zoom's in, it's taking the coordinate in canvas units where the user's mouse was, inverse-transforming that using the context transformation thus-far, to get the location in context coordinate space that was clicked on. The context origin is moved to that location, zoomed, then returned to it's previous location.

References:

• Safari HTML5 Canvas Guide: Translation, Rotation, and Scaling

Answer 2

You seem to be way overthinking transforms!

Here’s the simple rule:

If you apply any set of transforms, then you must undo all of them if you want to get back to your untransformed state.

Period !!!!

So let say you do these 4 transforms:

• Do #1. context.translate(100,100);
• Do #2. context.scale(2,2);
• Do #3. context.translate(-20,50);
• Do #4. context.scale(10,10);

To get back to your original untransformed state, you must undo in exactly reverse order:

• Undo #4: context.scale( 0.10, 0.10 ); // since we scaled 10x, we must unscale by 0.10
• Undo #3: context.translate(20,-50);
• Undo #2: context.scale( 0.50, 0.50 ); // since we scaled 2x, we must unscale by 0.50
• Undo #1: context.translate(-100,-100);

Think of it like walking to your friends house.

You turn Right + Left + Right.

Then to go home you must reverse that: Left + Right + Left

You must undo your walking path in exactly the reverse of your original walk.

That’s how transforms work too.

That’s Why !!