Drawing complex shapes: Arcs and paths
Video: Drawing complex shapes: Arcs and pathsDrawing complex shapes: Arcs and paths provides you with in-depth training on Developer. Taught by Joe Marini as part of the HTML5: Graphics and Animation with Canvas
Viewers: in countries Watching now:
Drawing complex shapes: Arcs and paths provides you with in-depth training on Developer. Taught by Joe Marini as part of the HTML5: Graphics and Animation with Canvas
One of the most exciting additions that HTML5 offers to designers is the ability to draw free-form graphics on a drawing surface known as the Canvas. In this course, author Joe Marini introduces the technical concepts behind Canvas and shows how to perform drawing operations directly in a web page. The course covers drawing basic and complex shapes, setting colors and styles, adding shadows, patterns, and gradients, more advanced techniques such as scaling, rotating, and compositing objects, and how to incorporate Canvas elements in a slideshow and an animation.
- Understanding the differences between Canvas and SVG Graphics
- Drawing shapes
- Drawing arcs and paths
- Rendering text
- Using clipping paths
- Drawing images and video
- Transforming objects with the translate tag
- Manipulating raw pixels
- Applying a custom transformation
- Creating an animation or slideshow control with Canvas
Drawing complex shapes: Arcs and paths
Up until now, we've seen how to draw simple shapes like rectangles and lines. Now let's take a look at drawing more complex shapes, specifically arcs and paths. So, what is a path? A path is basically a set of connected points, and the points are connected by lines or by curves, and a path is either open or closed. The current drawing context always has one, and only one, current drawing path. Now, paths can be open or closed. A closed path has an end point that is the same as its starting point. Or the canvas can automatically draw a line from the ending point to the starting point and automatically close the path for you.
Now, to begin creating a path, you use the beginPath method, and it doesn't take any arguments. You just simply say beginPath and start drawing your paths. To add paths, you basically use one or more path-drawing routines, and if you've watched me in the previous movies, you've seen how to do this with lines. In this movie, we're going to see how to do it with arcs. To stroke the current path, you just call the stroke function, again with no arguments. And to fill it, you just call fill. Both of those are no argument functions that will stroke and fill paths. And to close the current path, should you decide to close it, you just call closePath.
In case the end point is not the same as the start point, the canvas will close it for you. Let's talk about arcs for a moment. Arcs are curves that are portions of a circle, and in fact a circle is an arc. It's just a special case. It's a full 360-degree arc. So to draw an arc, you can either use the arc function or the arcTo function. So the arc function has several arguments. The first is the X and Y point, that if the arc was a full circle, would serve as the center of the circle.
The r argument is the radius, which is how far the arc is out from this imaginary circle center right here. Now, to actually stroke the path along the edge of the circle that the arc represents, you have a starting angle and an ending angle. And then the last argument is true if you want the arc to go anticlockwise rather than clockwise, which is the default direction. Now, the other arc function is arcTo, and that takes two control points and a radius. And then finally the closePath function, which I mentioned earlier, which closes the current drawing path.
Now we should make a special note that when you use angles, such as the angles here, these angles are radians; these are not degrees. So if you want to use degrees for your arguments instead of radians, you can use a very simple mathematical function right here, which takes Math.PI, you divide by 180, and you multiply by degrees and that will give you radians. Let's take a look at some arc examples. Remember 360 degrees is the same as 2 pi radians. So in this arc, we have a starting point and an ending point, and the way we do that was by stroking a 90-degree arc.
So we call beginPath to begin the path, and we create an arc with its center point at 50 and 150. That will be right about this center point right here. This 100 value is the radius, which is about 100 pixels from the center out to the edge of the arc. Then we start at the 1.5-radian mark, and we go to the 2-radian mark, so we'll start there and it will end at this angle right here. Let's look at another example. In this case, we have an arc that's going the other way. So to stroke 270 degrees arc, again, we call beginPath.
We have the X and Y center--that will be this center point right here. Radius is still 100. And we're going from the zero-angle part all the way around here to the 1.5-radian mark, anticlockwise in this case. So let's actually take a look at some real examples in code to see how this works. Here we are on the code editor, and I've got my snippets open to the paths section, and I've got my paths_starts example file for this chapter opened up. So let's go ahead and copy and paste some of these examples. So I will take these first lines right here, along with the first example, I'll copy and paste, okay, and save. And let's go to the browser, and we'll choose paths.start.
You can see that we've got three line segments for this particular path. Let's take a look. We've got the strokeStyle blue, a fillStyle of red, which we are now currently using. The lineWidth is 5, and here's where we are to draw the open path. So we call beginPath. We move the pen to its starting location, we add three line segments, and then we stroke, and that will stroke the current path so those three lines segments gets drawn. Okay, let's copy the next one. This time we're going to draw a closed path, so we'll copy and we'll paste.
So in this case, we call beginPath like we always do. Same kind of operation. We move the pen, draw three line segments, only in this case we call closePath before we call stroke. So let's save and let's go back to the browser and refresh. And you can see that there's the same three line segments, but in this case because of the closePath call, the canvas added this final line for us to make the ending point the same as the starting point. One more example. Let's go back to the code, back to the snippets.
This time we're going to draw a closed path. So I'm going to copy these lines here. Now we're going to paste. So one more time, three line segments, only in this case, in addition to stroke, we're going to call fill--and notice there's no closePath call here. So we save, and then we go back to the browser and we refresh. And in this case you can see that the path was stroked-- it's not closed, but it was filled in as if it were closed, there is an imaginary boundary right here--using the current fillStyle.
So now that we've seen paths, let's take a look at arcs. I have got my arcs_start example open right here, go back to my snippets. Let's go back up to the arcs, which are right here. I am going to copy the first example here and paste it. We'll save, and let's show it in the browser.
So that's the 90-degree arc right there. And just to show you the effect of changing the radius, let's make the radius 150 this time. Save, and we'll refresh and watch. So you can see that the center point stayed the same, but the radius got bigger. Let's copy some more. In this case, I want to copy this one, and then we'll paste.
Now in this case, we're going to stroke a three-quarter arc. So we've moved the center point over and we have got 100 radius. And in this case we've got these two angles, right? We've got a starting angle. We've got an ending angle. So we're going to save that and refresh it. You can see that the arc has now been drawn in the counterclockwise direction, starting from here, going all the way around three quarters to this point, around that center point right there. Okay, last example. Let's do a circle, and we'll copy and we'll paste.
All right, so in this example, we've started at zero. We go the full 2 pi radians. Save, we refresh, and there's our circle using the fill and stroke style, because you can see we call both fill and stroke. And just to show you how radians work, let's just do a simple example with degrees. Let's just say 'var degrees equals 360', and we'll say 'var radians equals Math.PI/180 * degrees', and we'll just substitute radians in there for this one.
Now since we're starting off with 360, it's going to have no effect. But just to show you that it is the same, let's refresh. So it's the same. But let's just change that to I don't know, 173 degrees, and we'll save, and we'll refresh. And you can see that it's not quite half a circle, because it's not 180 degrees, but you get the idea. You can use radians, or you can have degrees and convert them to radians. What we've seen in this example is how to draw paths and arcs using the canvas path- and arc-drawing routines. And we've seen how to draw open and closed paths, as well have stroke and fill paths. And then finally, we saw how to draw arcs in both directions using radians and degrees.
There are currently no FAQs about HTML5: Graphics and Animation with Canvas.