How To Draw A Box In Javascript
Drawing shapes with canvas
- « Previous
- Adjacent »
At present that we take set upwards our canvas surround, we tin get into the details of how to draw on the canvas. By the end of this article, you volition have learned how to describe rectangles, triangles, lines, arcs and curves, providing familiarity with some of the basic shapes. Working with paths is essential when drawing objects onto the canvas and we will encounter how that tin be washed.
The grid
Before we can start drawing, we demand to talk almost the canvas grid or coordinate infinite. Our HTML skeleton from the previous page had a canvass chemical element 150 pixels wide and 150 pixels high.
Normally 1 unit of measurement in the filigree corresponds to 1 pixel on the canvas. The origin of this filigree is positioned in the top left corner at coordinate (0,0). All elements are placed relative to this origin. So the position of the top left corner of the blue square becomes x pixels from the left and y pixels from the top, at coordinate (x,y). Later in this tutorial we'll encounter how we can interpret the origin to a different position, rotate the grid and even scale information technology, but for now we'll stick to the default.
Cartoon rectangles
Unlike SVG, <canvas> only supports ii archaic shapes: rectangles and paths (lists of points continued by lines). All other shapes must exist created by combining one or more paths. Luckily, we have an assortment of path drawing functions which make information technology possible to compose very complex shapes.
Commencement let's wait at the rectangle. There are iii functions that draw rectangles on the canvas:
-
fillRect(ten, y, width, pinnacle) -
Draws a filled rectangle.
-
strokeRect(x, y, width, height) -
Draws a rectangular outline.
-
clearRect(x, y, width, acme) -
Clears the specified rectangular area, making information technology fully transparent.
Each of these three functions takes the same parameters. x and y specify the position on the canvas (relative to the origin) of the pinnacle-left corner of the rectangle. width and height provide the rectangle's size.
Beneath is the draw() function from the previous folio, merely now it is making employ of these three functions.
Rectangular shape example
function draw ( ) { var canvass = document. getElementById ( 'canvas' ) ; if (canvas.getContext) { var ctx = canvas. getContext ( 'second' ) ; ctx. fillRect ( 25 , 25 , 100 , 100 ) ; ctx. clearRect ( 45 , 45 , 60 , threescore ) ; ctx. strokeRect ( 50 , l , 50 , 50 ) ; } } This case's output is shown below.
| Screenshot | Live sample |
|---|---|
 |
The fillRect() role draws a big black foursquare 100 pixels on each side. The clearRect() function and then erases a 60x60 pixel square from the center, and then strokeRect() is chosen to create a rectangular outline 50x50 pixels within the cleared foursquare.
In upcoming pages nosotros'll encounter two alternative methods for clearRect(), and we'll too come across how to change the color and stroke style of the rendered shapes.
Unlike the path functions nosotros'll encounter in the adjacent department, all iii rectangle functions describe immediately to the sail.
Cartoon paths
Now let's wait at paths. A path is a list of points, connected by segments of lines that can be of different shapes, curved or not, of different width and of different color. A path, or fifty-fifty a subpath, can be airtight. To make shapes using paths, we accept some actress steps:
- First, you create the path.
- So you use cartoon commands to depict into the path.
- Once the path has been created, yous can stroke or fill the path to render it.
Here are the functions used to perform these steps:
-
beginPath() -
Creates a new path. Once created, future drawing commands are directed into the path and used to build the path up.
- Path methods
-
Methods to set different paths for objects.
-
closePath() -
Adds a direct line to the path, going to the showtime of the electric current sub-path.
-
stroke() -
Draws the shape by stroking its outline.
-
fill() -
Draws a solid shape past filling the path'southward content expanse.
The commencement step to create a path is to call the beginPath(). Internally, paths are stored as a list of sub-paths (lines, arcs, etc) which together class a shape. Every fourth dimension this method is called, the list is reset and nosotros tin can start drawing new shapes.
Note: When the current path is empty, such as immediately after calling beginPath(), or on a newly created canvas, the first path construction control is ever treated equally a moveTo(), regardless of what it actually is. For that reason, you volition almost e'er desire to specifically set your starting position later on resetting a path.
The 2d step is calling the methods that really specify the paths to be drawn. We'll see these shortly.
The 3rd, and an optional step, is to call closePath(). This method tries to shut the shape by drawing a straight line from the electric current point to the start. If the shape has already been closed or at that place'southward but ane indicate in the listing, this function does nothing.
Note: When you call fill(), any open shapes are closed automatically, then you don't accept to call closePath(). This is not the instance when yous call stroke().
Drawing a triangle
For case, the lawmaking for drawing a triangle would look something like this:
function draw ( ) { var sheet = document. getElementById ( 'sail' ) ; if (canvas.getContext) { var ctx = canvas. getContext ( '2d' ) ; ctx. beginPath ( ) ; ctx. moveTo ( 75 , 50 ) ; ctx. lineTo ( 100 , 75 ) ; ctx. lineTo ( 100 , 25 ) ; ctx. fill ( ) ; } } The effect looks like this:
| Screenshot | Live sample |
|---|---|
 |
Moving the pen
One very useful office, which doesn't really draw anything only becomes part of the path list described in a higher place, is the moveTo() function. You lot tin can probably best retrieve of this as lifting a pen or pencil from 1 spot on a piece of paper and placing it on the adjacent.
-
moveTo(x, y) -
Moves the pen to the coordinates specified past
xandy.
When the canvas is initialized or beginPath() is called, you lot typically will want to utilize the moveTo() function to place the starting point somewhere else. We could also utilize moveTo() to draw unconnected paths. Take a await at the smiley face below.
To endeavour this for yourself, you lot can utilize the code snippet below. Simply paste information technology into the draw() function nosotros saw before.
role draw ( ) { var canvas = document. getElementById ( 'canvas' ) ; if (canvas.getContext) { var ctx = canvas. getContext ( '2d' ) ; ctx. beginPath ( ) ; ctx. arc ( 75 , 75 , l , 0 , Math. PI * two , true ) ; // Outer circle ctx. moveTo ( 110 , 75 ) ; ctx. arc ( 75 , 75 , 35 , 0 , Math. PI , false ) ; // Oral fissure (clockwise) ctx. moveTo ( 65 , 65 ) ; ctx. arc ( threescore , 65 , v , 0 , Math. PI * 2 , true ) ; // Left middle ctx. moveTo ( 95 , 65 ) ; ctx. arc ( xc , 65 , 5 , 0 , Math. PI * ii , truthful ) ; // Right eye ctx. stroke ( ) ; } } The result looks like this:
| Screenshot | Live sample |
|---|---|
 |
If you'd similar to see the connecting lines, you can remove the lines that call moveTo().
Note: To learn more near the arc() function, see the Arcs department below.
Lines
For drawing straight lines, use the lineTo() method.
-
lineTo(10, y) -
Draws a line from the electric current drawing position to the position specified by
xandy.
This method takes 2 arguments, ten and y, which are the coordinates of the line's end betoken. The starting signal is dependent on previously drawn paths, where the end point of the previous path is the starting point for the following, etc. The starting indicate can also be changed by using the moveTo() method.
The example beneath draws two triangles, i filled and one outlined.
part draw ( ) { var canvas = certificate. getElementById ( 'canvas' ) ; if (canvas.getContext) { var ctx = sheet. getContext ( '2d' ) ; // Filled triangle ctx. beginPath ( ) ; ctx. moveTo ( 25 , 25 ) ; ctx. lineTo ( 105 , 25 ) ; ctx. lineTo ( 25 , 105 ) ; ctx. fill up ( ) ; // Stroked triangle ctx. beginPath ( ) ; ctx. moveTo ( 125 , 125 ) ; ctx. lineTo ( 125 , 45 ) ; ctx. lineTo ( 45 , 125 ) ; ctx. closePath ( ) ; ctx. stroke ( ) ; } } This starts by calling beginPath() to beginning a new shape path. Nosotros then utilize the moveTo() method to move the starting point to the desired position. Beneath this, two lines are drawn which make up two sides of the triangle.
| Screenshot | Live sample |
|---|---|
 |
You'll notice the difference between the filled and stroked triangle. This is, equally mentioned above, because shapes are automatically airtight when a path is filled, just not when they are stroked. If we left out the closePath() for the stroked triangle, merely two lines would have been fatigued, non a consummate triangle.
Arcs
To draw arcs or circles, nosotros use the arc() or arcTo() methods.
-
arc(x, y, radius, startAngle, endAngle, counterclockwise) -
Draws an arc which is centered at (x, y) position with radius r starting at startAngle and ending at endAngle going in the given management indicated by counterclockwise (defaulting to clockwise).
-
arcTo(x1, y1, x2, y2, radius) -
Draws an arc with the given control points and radius, connected to the previous point past a straight line.
Let'south have a more detailed await at the arc method, which takes six parameters: x and y are the coordinates of the center of the circumvolve on which the arc should be drawn. radius is self-explanatory. The startAngle and endAngle parameters define the start and end points of the arc in radians, along the bend of the circle. These are measured from the x centrality. The counterclockwise parameter is a Boolean value which, when true, draws the arc counterclockwise; otherwise, the arc is fatigued clockwise.
Annotation: Angles in the arc function are measured in radians, not degrees. To convert degrees to radians you can use the following JavaScript expression: radians = (Math.PI/180)*degrees.
The following example is a little more than complex than the ones we've seen above. It draws 12 different arcs all with different angles and fills.
The two for loops are for looping through the rows and columns of arcs. For each arc, we showtime a new path past calling beginPath(). In the lawmaking, each of the parameters for the arc is in a variable for clarity, only you lot wouldn't necessarily do that in existent life.
The 10 and y coordinates should be articulate enough. radius and startAngle are fixed. The endAngle starts at 180 degrees (half a circle) in the first column and is increased by steps of 90 degrees, culminating in a complete circle in the concluding column.
The statement for the clockwise parameter results in the first and third row being fatigued every bit clockwise arcs and the second and quaternary row as counterclockwise arcs. Finally, the if statement makes the top one-half stroked arcs and the bottom half filled arcs.
Note: This example requires a slightly larger canvass than the others on this page: 150 x 200 pixels.
function depict ( ) { var canvass = document. getElementById ( 'canvass' ) ; if (canvas.getContext) { var ctx = sheet. getContext ( '2d' ) ; for ( var i = 0 ; i < 4 ; i++ ) { for ( var j = 0 ; j < iii ; j++ ) { ctx. beginPath ( ) ; var x = 25 + j * fifty ; // x coordinate var y = 25 + i * 50 ; // y coordinate var radius = 20 ; // Arc radius var startAngle = 0 ; // Starting point on circle var endAngle = Math. PI + (Math. PI * j) / two ; // Stop point on circumvolve var counterclockwise = i % two !== 0 ; // clockwise or counterclockwise ctx. arc (x, y, radius, startAngle, endAngle, counterclockwise) ; if (i > 1 ) { ctx. make full ( ) ; } else { ctx. stroke ( ) ; } } } } } | Screenshot | Live sample |
|---|---|
 |
Bezier and quadratic curves
The next type of paths available are Bézier curves, available in both cubic and quadratic varieties. These are generally used to depict complex organic shapes.
-
quadraticCurveTo(cp1x, cp1y, ten, y) -
Draws a quadratic Bézier curve from the current pen position to the end indicate specified by
xandy, using the control betoken specified pastcp1xandcp1y. -
bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) -
Draws a cubic Bézier curve from the electric current pen position to the end point specified by
xandy, using the control points specified by (cp1x,cp1y) and (cp2x, cp2y).
The departure betwixt these is that a quadratic Bézier curve has a showtime and an terminate indicate (blueish dots) and simply one control point (indicated past the red dot) while a cubic Bézier bend uses two control points. 
The x and y parameters in both of these methods are the coordinates of the end point. cp1x and cp1y are the coordinates of the first control bespeak, and cp2x and cp2y are the coordinates of the second control point.
Using quadratic and cubic Bézier curves can exist quite challenging, because unlike vector drawing software similar Adobe Illustrator, we don't have direct visual feedback as to what nosotros're doing. This makes it pretty hard to describe complex shapes. In the following example, nosotros'll be cartoon some elementary organic shapes, but if you have the time and, most of all, the patience, much more complex shapes can exist created.
There's zip very difficult in these examples. In both cases we see a succession of curves existence drawn which finally upshot in a complete shape.
Quadratic Bezier curves
This example uses multiple quadratic Bézier curves to render a oral communication balloon.
office draw ( ) { var canvas = document. getElementById ( 'canvas' ) ; if (canvas.getContext) { var ctx = canvas. getContext ( '2d' ) ; // Quadratic curves example ctx. beginPath ( ) ; ctx. moveTo ( 75 , 25 ) ; ctx. quadraticCurveTo ( 25 , 25 , 25 , 62.5 ) ; ctx. quadraticCurveTo ( 25 , 100 , 50 , 100 ) ; ctx. quadraticCurveTo ( 50 , 120 , 30 , 125 ) ; ctx. quadraticCurveTo ( lx , 120 , 65 , 100 ) ; ctx. quadraticCurveTo ( 125 , 100 , 125 , 62.v ) ; ctx. quadraticCurveTo ( 125 , 25 , 75 , 25 ) ; ctx. stroke ( ) ; } } | Screenshot | Live sample |
|---|---|
 |
Cubic Bezier curves
This example draws a heart using cubic Bézier curves.
function draw ( ) { var canvas = document. getElementById ( 'sheet' ) ; if (canvas.getContext) { var ctx = sail. getContext ( '2d' ) ; // Cubic curves case ctx. beginPath ( ) ; ctx. moveTo ( 75 , xl ) ; ctx. bezierCurveTo ( 75 , 37 , lxx , 25 , l , 25 ) ; ctx. bezierCurveTo ( 20 , 25 , twenty , 62.5 , 20 , 62.5 ) ; ctx. bezierCurveTo ( 20 , lxxx , 40 , 102 , 75 , 120 ) ; ctx. bezierCurveTo ( 110 , 102 , 130 , 80 , 130 , 62.5 ) ; ctx. bezierCurveTo ( 130 , 62.5 , 130 , 25 , 100 , 25 ) ; ctx. bezierCurveTo ( 85 , 25 , 75 , 37 , 75 , 40 ) ; ctx. fill ( ) ; } } | Screenshot | Live sample |
|---|---|
 |
Rectangles
In addition to the three methods we saw in Drawing rectangles, which draw rectangular shapes straight to the canvas, there's as well the rect() method, which adds a rectangular path to a currently open path.
-
rect(x, y, width, height) -
Draws a rectangle whose peak-left corner is specified by (
x,y) with the specifiedwidthandsuperlative.
Before this method is executed, the moveTo() method is automatically chosen with the parameters (x,y). In other words, the current pen position is automatically reset to the default coordinates.
Making combinations
So far, each example on this page has used only one type of path function per shape. All the same, there'south no limitation to the number or types of paths you can use to create a shape. So in this final example, let'south combine all of the path functions to make a set of very famous game characters.
function draw ( ) { var sail = document. getElementById ( 'canvas' ) ; if (canvass.getContext) { var ctx = canvas. getContext ( '2d' ) ; roundedRect (ctx, 12 , 12 , 150 , 150 , 15 ) ; roundedRect (ctx, xix , nineteen , 150 , 150 , 9 ) ; roundedRect (ctx, 53 , 53 , 49 , 33 , 10 ) ; roundedRect (ctx, 53 , 119 , 49 , 16 , 6 ) ; roundedRect (ctx, 135 , 53 , 49 , 33 , 10 ) ; roundedRect (ctx, 135 , 119 , 25 , 49 , 10 ) ; ctx. beginPath ( ) ; ctx. arc ( 37 , 37 , thirteen , Math. PI / 7 , -Math. PI / vii , false ) ; ctx. lineTo ( 31 , 37 ) ; ctx. fill ( ) ; for ( var i = 0 ; i < 8 ; i++ ) { ctx. fillRect ( 51 + i * 16 , 35 , 4 , 4 ) ; } for (i = 0 ; i < 6 ; i++ ) { ctx. fillRect ( 115 , 51 + i * 16 , 4 , 4 ) ; } for (i = 0 ; i < viii ; i++ ) { ctx. fillRect ( 51 + i * sixteen , 99 , iv , 4 ) ; } ctx. beginPath ( ) ; ctx. moveTo ( 83 , 116 ) ; ctx. lineTo ( 83 , 102 ) ; ctx. bezierCurveTo ( 83 , 94 , 89 , 88 , 97 , 88 ) ; ctx. bezierCurveTo ( 105 , 88 , 111 , 94 , 111 , 102 ) ; ctx. lineTo ( 111 , 116 ) ; ctx. lineTo ( 106.333 , 111.333 ) ; ctx. lineTo ( 101.666 , 116 ) ; ctx. lineTo ( 97 , 111.333 ) ; ctx. lineTo ( 92.333 , 116 ) ; ctx. lineTo ( 87.666 , 111.333 ) ; ctx. lineTo ( 83 , 116 ) ; ctx. fill ( ) ; ctx.fillStyle = 'white' ; ctx. beginPath ( ) ; ctx. moveTo ( 91 , 96 ) ; ctx. bezierCurveTo ( 88 , 96 , 87 , 99 , 87 , 101 ) ; ctx. bezierCurveTo ( 87 , 103 , 88 , 106 , 91 , 106 ) ; ctx. bezierCurveTo ( 94 , 106 , 95 , 103 , 95 , 101 ) ; ctx. bezierCurveTo ( 95 , 99 , 94 , 96 , 91 , 96 ) ; ctx. moveTo ( 103 , 96 ) ; ctx. bezierCurveTo ( 100 , 96 , 99 , 99 , 99 , 101 ) ; ctx. bezierCurveTo ( 99 , 103 , 100 , 106 , 103 , 106 ) ; ctx. bezierCurveTo ( 106 , 106 , 107 , 103 , 107 , 101 ) ; ctx. bezierCurveTo ( 107 , 99 , 106 , 96 , 103 , 96 ) ; ctx. make full ( ) ; ctx.fillStyle = 'black' ; ctx. beginPath ( ) ; ctx. arc ( 101 , 102 , 2 , 0 , Math. PI * 2 , true ) ; ctx. fill ( ) ; ctx. beginPath ( ) ; ctx. arc ( 89 , 102 , 2 , 0 , Math. PI * 2 , true ) ; ctx. make full ( ) ; } } // A utility function to draw a rectangle with rounded corners. function roundedRect ( ctx, ten, y, width, height, radius ) { ctx. beginPath ( ) ; ctx. moveTo (x, y + radius) ; ctx. arcTo (x, y + superlative, 10 + radius, y + height, radius) ; ctx. arcTo (ten + width, y + height, 10 + width, y + summit - radius, radius) ; ctx. arcTo (ten + width, y, x + width - radius, y, radius) ; ctx. arcTo (x, y, x, y + radius, radius) ; ctx. stroke ( ) ; } The resulting paradigm looks like this:
| Screenshot | Live sample |
|---|---|
 |
We won't get over this in particular, since it's actually surprisingly simple. The virtually important things to notation are the apply of the fillStyle holding on the drawing context, and the use of a utility function (in this case roundedRect()). Using utility functions for $.25 of drawing you lot do ofttimes can exist very helpful and reduce the amount of lawmaking you lot need, as well as its complexity.
We'll take another expect at fillStyle, in more detail, later in this tutorial. Here, all nosotros're doing is using it to modify the fill colour for paths from the default colour of black to white, so back once again.
Path2D objects
As nosotros have seen in the final case, there can be a series of paths and drawing commands to draw objects onto your canvas. To simplify the code and to improve performance, the Path2D object, available in recent versions of browsers, lets yous cache or record these drawing commands. You are able to play dorsum your paths quickly. Let's encounter how we can construct a Path2D object:
-
Path2D() -
The
Path2D()constructor returns a newly instantiatedPath2Dobject, optionally with another path as an argument (creates a copy), or optionally with a string consisting of SVG path data.
new Path2D ( ) ; // empty path object new Path2D (path) ; // re-create from another Path2D object new Path2D (d) ; // path from SVG path data All path methods like moveTo, rect, arc or quadraticCurveTo, etc., which we got to know higher up, are available on Path2D objects.
The Path2D API also adds a way to combine paths using the addPath method. This can be useful when you want to build objects from several components, for case.
-
Path2D.addPath(path [, transform]) -
Adds a path to the electric current path with an optional transformation matrix.
Path2D example
In this example, we are creating a rectangle and a circle. Both are stored as a Path2D object, so that they are bachelor for later usage. With the new Path2D API, several methods got updated to optionally have a Path2D object to utilise instead of the current path. Here, stroke and fill are used with a path argument to describe both objects onto the canvas, for example.
function draw ( ) { var canvas = document. getElementById ( 'canvas' ) ; if (canvass.getContext) { var ctx = canvass. getContext ( '2d' ) ; var rectangle = new Path2D ( ) ; rectangle. rect ( ten , ten , fifty , 50 ) ; var circle = new Path2D ( ) ; circle. arc ( 100 , 35 , 25 , 0 , 2 * Math. PI ) ; ctx. stroke (rectangle) ; ctx. fill (circle) ; } } | Screenshot | Live sample |
|---|---|
 |
Using SVG paths
Some other powerful feature of the new sail Path2D API is using SVG path information to initialize paths on your canvas. This might allow yous to pass around path data and re-use them in both, SVG and sheet.
The path will move to signal (M10 10) and then motility horizontally 80 points to the right (h 80), then 80 points down (v 80), then 80 points to the left (h -fourscore), and and so back to the showtime (z). You can encounter this example on the Path2D constructor page.
var p = new Path2D ( 'M10 10 h 80 v lxxx h -80 Z' ) ; - « Previous
- Next »
Source: https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API/Tutorial/Drawing_shapes
Posted by: sandovalventing.blogspot.com
0 Response to "How To Draw A Box In Javascript"
Post a Comment