How to animate fill opacity of a context in HTML5 canvas? - javascript
How can I animate fill opacity of a context (or add a fade-in effect) in HTML canvas?
For example at following example the ctx.fillStyle fill opacity is set to 0 and how can I animate it to 1?
var c = document.getElementById("myCanvas");
var ctx = c.getContext("2d");
ctx.beginPath();
ctx.fillStyle = 'rgba(255, 165, 0, 0)';
ctx.rect(20, 20, 150, 100);
ctx.fill();
<canvas id="myCanvas" width="300" height="300" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.
</canvas>
You can't "animate" like you would with CSS. With a canvas, you're drawing the primative, so you'll have to do the math and timing yourself.
Here is a simple linear progression from one value to another.
var c = document.getElementById("myCanvas");
var ctx = c.getContext("2d");
const duration = 1000; // ms
const step = 10; // ms
let opacity = 0;
function draw() {
if (opacity == 1) return;
opacity += (step / duration);
ctx.clearRect(20, 20, 150, 100);
ctx.beginPath();
ctx.fillStyle = `rgba(255, 165, 0, ${opacity})`;
ctx.rect(20, 20, 150, 100);
ctx.fill();
setTimeout(draw, step);
}
draw();
<canvas id="myCanvas" width="300" height="300" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.</canvas>
Basically, you keep track of the current opacity, how long you want it to go, and how frequently you want it to trigger. Then, you increase your opacity by the percent of your step to your duration and redraw.
Also, since you are dealing with opacity, you have to remember to clear it each step as well, or it'll get dark really fast.
You could also use window.requestAnimationFrame, but then (if you want to control the speed), you'll need to track time instead of step:
var c = document.getElementById("myCanvas");
var ctx = c.getContext("2d");
const duration = 1000; // ms
let lastTime = performance.now();
let opacity = 0;
function draw(now) {
if (opacity >= 1) return;
opacity += ((now - lastTime) / duration);
lastTime = now;
ctx.clearRect(20, 20, 150, 100);
ctx.beginPath();
ctx.fillStyle = `rgba(255, 165, 0, ${opacity})`;
ctx.rect(20, 20, 150, 100);
ctx.fill();
window.requestAnimationFrame(draw);
}
draw(lastTime);
<canvas id="myCanvas" width="300" height="300" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.</canvas>
Notice now instead of opacity += step / duration, we're using the number of milliseconds since our last update opacity += (now - lastTime) / duration.
If you want to do different transitions (like step-in-out), you would need to tweak the amount of opacity increase as a factor of time.
You can achieve this using window.requestAnimationFrame:
var
/* Save the canvas' context. */
ctx = document.getElementById("myCanvas").getContext("2d"),
/* The starting opacity. */
opacity = 0,
/* The duration of the animation in milliseconds. */
duration = 500,
/* Cache the starting time in milliseconds since page load. */
past = performance.now();
/* The animation function. */
function animate(present) {
/* Find the difference between the previous and current times. */
var step = present - past;
/* Set the present time to past. */
past = present;
/* Increment the opacity by a linear step. */
opacity += step / duration;
/* Create the shape. */
ctx.beginPath();
ctx.fillStyle = "rgba(255, 165, 0, " + opacity + ")";
ctx.clearRect(20, 20, 150, 100);
ctx.rect(20, 20, 150, 100);
ctx.fill();
/* Continue the animation until the opacity is 1. */
if (opacity < 1) window.requestAnimationFrame(animate);
}
/* Start the animation. */
window.requestAnimationFrame(animate);
<canvas id="myCanvas" width="300" height="300" style="border:1px solid #d3d3d3;">
Your browser does not support the HTML5 canvas tag.
</canvas>
Notes:
You can adjust the speed of the animation by changing the duration to what suits you best. The value is in milliseconds.
On each call of animate, we use clearRect to clear the canvas, to avoid creating one shape on top of another, so that the opacity is incremented as expected.
Different browsers handle requestAnimationFrame differently, so to achieve a consistent, cross-browser result you must use a polyfill that accounts for the differences between browsers. I have provided one below.
Another way to proceed with the animation would be through the use of setInterval, but I believe this is a thing of the past. See this article for more.
Polyfill:
(This polyfill is a modified version of this one, created by Paul Irish)
;(function (prefices, lastTime) {
/* Iterate over every browser-engine-specific prefix. */
for (var i = 0; i < prefices.length && !window.requestAnimationFrame; i++) {
/* Normalise requestAnimationFrame and cancelAnimationFrame. */
window.requestAnimationFrame = window[prefices[i] + "RequestAnimationFrame"];
window.cancelAnimationFrame =
window[prefices[i] + "CancelAnimationFrame"] ||
window[prefices[i] + "CancelRequestAnimationFrame"];
}
/* If requestAnimationFrame is not defined use a custom function. */
window.requestAnimationFrame = window.requestAnimationFrame
|| function (callback, element) {
var
/* Save the present time and the time between it and the last time. */
now = Date.now() || new Date().getTime(),
timeToCall = Math.max(0, 16 - (now - lastTime)),
/* Save the id of the timeout. */
id = window.setTimeout(function () {
/* Call the callback function passing the time passed & the element. */
callback(now + timeToCall, element);
}, timeToCall);
/* Update the last time with the present time plus the time in between. */
lastTime = now + timeToCall;
/* Return the id of the timeout. */
return id;
};
/* If cancelAnimationFrame is not defined set it to clear the timeout. */
window.cancelAnimationFrame = window.cancelAnimationFrame || function (id) {
clearTimeout(id);
}
})(["webkit", "moz", "ms", "o"], 0);
Related
Gradually fade to colour using JS
I am trying to make a rectangle gradually change its colour (fade) from yellow to white using Javascript after a button is pressed. Sadly my code does not work. Could you help me figure out what is wrong with the code and how to fix it? I have just begun studying Javascript. Sorry, if this question is stupid. Thank you in advance. This is my code: <!DOCTYPE html> <html> <body> <canvas id="myCanvas" width="300" height="150" style="border:1px solid #d3d3d3;"> Your browser does not support the HTML5 canvas tag.</canvas> // create canvas to work with <button onclick="fade(ctx)">Change the colour!</button> <script> var c = document.getElementById("myCanvas"); var ctx = c.getContext("2d"); //set context ctx.rect(20, 20, 150, 100); // draw a rectangle ctx.stroke(); // with border ctx.fillStyle="#FFFF00"; // fill with yellow ctx.fillRect(20,20,150,100); function fade(ctx) { // fade function responsible for changing colour var dom = getElementById(ctx), level = 1; // new object based on rectangle object, initial iterator is set to 1 function step() { // inner step function var h = level.toString(16); dom.fillStyle = '#FFFF' + h + h; // construct a new colour using h variable if (level < 15) { level += 1; setTimeout(step, 100); // do this after every 100 ms } } setTimeout(step, 100); } </script> </body> </html>
You almost have it with your code though. You are passing the context into the function already so no need for the getElementById(ctx) bit. In fact that will give you an error so remove that line from your code. Instead directly set the fillStyle on the ctx variable like this: ctx.fillStyle = '#FFFF' + h + h; and you also need to redraw the rectangle, so add this line: ctx.fillRect(20,20,150,100); after you set the colour. And that will do it.
html5 draw gaussian function using bezierCurveTo
I have been trying to draw gaussin-like function using bezierCurveTo find the code below <canvas id="thisCan" width="0px" height="0px" style="border:1px solid #d3d3d3;"> Your browser does not support the HTML5 canvas tag. </canvas> <script> (function() { var // Obtain a reference to the canvas element // using its id. htmlCanvas = document.getElementById('thisCan'), // Obtain a graphics context on the // canvas element for drawing. ctx = htmlCanvas.getContext('2d'); var width = 0; var height = 0; // Start listening to resize events and // draw canvas. initialize(); function initialize() { // Register an event listener to // call the resizeCanvas() function each time // the window is resized. window.addEventListener('resize', resizeCanvas, false); // Draw canvas border for the first time. resizeCanvas(); } // Display custom canvas. // In this case it's a blue, 5 pixel border that // resizes along with the browser window. function redraw() { ctx.beginPath(); ctx.moveTo(width/2, 0); ctx.bezierCurveTo(150, 119, 186, 121, 66, 185); ctx.moveTo(width/2 + width * 0.08 , 0); ctx.bezierCurveTo(344, 119, 344, 121, 504, 185); ctx.stroke(); } // Runs each time the DOM window resize event fires. // Resets the canvas dimensions to match window, // then draws the new borders accordingly. function resizeCanvas() { var contentElement = document.getElementsByClassName("content-box post")[0] width = htmlCanvas.width = (contentElement.clientWidth * 0.75) height = htmlCanvas.height = (contentElement.offsetWidth*0.75 * 0.5); redraw(); } })(); </script> I am planning to draw many curves in between as well. But how do I make it parametric, based on width and height variables? I need to specify the control points using width and height parameters, so that it becomes window-size invariant. Is there a way?
Don't use Bezier curves if you want an exponent curve, they're different functions. Instead, just plot the function you actually need, with something like http://jsbin.com/nubutodosu/edit?js,output, where you define a Gaussian object: // Gaussian distribution generator var Gaussian = function(mean, std) { this.mean = mean; this.std = std; this.a = 1/Math.sqrt(2*Math.PI); }; Gaussian.prototype = { addStd: function(v) { this.std += v; }, get: function(x) { var f = this.a / this.std; var p = -1/2; var c = (x-this.mean)/this.std; c *= c; p *= c; return f * Math.pow(Math.E, p); }, generateValues: function(start, end) { var LUT = []; var step = (Math.abs(start)+Math.abs(end)) / 100; for(var i=start; i<end; i+=step) { LUT.push(this.get(i)); } return LUT; } }; And then you can give that a draw routine so that it can plot itself over the interval that you need: ... draw: function(ctx) { var points = this.generateValues(-10,10); var len = points.length; ctx.strokeStyle = "black"; ctx.beginPath(); var p0 = points[0]; ctx.moveTo(0, height - (height*p0)); points.forEach(function(p,i) { if(i===0) { return; } ctx.lineTo(width * i/len, height - (height*p)); p0 = p; }); ctx.stroke(); } ... So you build your array of values over the interval, then draw them on the canvas by "connecting the dots".
I managed to resolve it. To be specific, I was looking out for half-gaussian curve. I managed to figure out that guassian function has a very special property with respect to bezier curves. It might be elementary, but I could not find it on google. So this might be informative finding. If each control points of the cubic bezier curve reside on a "line parallel to X axis and passing through start point/end point", the resulting curve will be of a half guassian shape. e.g. On top of this finding, I have written the following code: <canvas id="thisCan" width="0px" height="0px"> Your browser does not support the HTML5 canvas tag. </canvas> <script> (function() { var // Obtain a reference to the canvas element // using its id. htmlCanvas = document.getElementById('thisCan'), // Obtain a graphics context on the // canvas element for drawing. ctx = htmlCanvas.getContext('2d'); // Start listening to resize events and // draw canvas. initialize(); function initialize() { // Register an event listener to // call the resizeCanvas() function each time // the window is resized. window.addEventListener('resize', resizeCanvas, false); // Draw canvas border for the first time. resizeCanvas(); } // Display custom canvas. // In this case it's a blue, 5 pixel border that // resizes along with the browser window. function redraw(width, height) { var start = width/2; var margin = width * 0.01; var height = (width / 3) - (margin * 4); var end_step = width/4 ctx.beginPath(); ctx.moveTo(start - margin, 0); ctx.bezierCurveTo((start - height/3), 0 , (start - height/3), height , end_step*1, height); ctx.moveTo(start + margin, 0); ctx.bezierCurveTo((start + height/3), 0 , (start + height/3), height , end_step*3, height); ctx.moveTo(start - margin, 0); ctx.bezierCurveTo((start - height*0.33), 0 , (start - height*0.16), height , end_step*1.5, height); ctx.moveTo(start + margin, 0); ctx.bezierCurveTo((start + height*0.33), 0 , (start + height*0.16), height , end_step*2.5, height); ctx.moveTo(start, 0); ctx.bezierCurveTo((start ), 0 , (start ), height , end_step*2, height); ctx.stroke(); } // Runs each time the DOM window resize event fires. // Resets the canvas dimensions to match window, // then draws the new borders accordingly. function resizeCanvas() { var width = 0; var height = 0; var contentElement = document.getElementsByClassName("content-box post")[0] width = htmlCanvas.width = (contentElement.clientWidth * 0.85) height = htmlCanvas.height = (contentElement.offsetWidth*0.85 * 0.33); redraw(width, height); } })(); </script> and the output:
How to make javascript canvas draw faster?
I have the following code to display an ECG. I use the canvas to draw the graph background (each grid of 2.5 mm dimension). Later I'm taking the y coordinates from an array array_1 (x coordinates are calculated within the program). The problem with this approach is it will take around 40 seconds to plot the entire graph since there are 1250 values within array array_1. What I could do is I could do the plotting part within a loop in which case, the entire graph is plotted as soon as the page is loaded. But, I need the plotting to happen over the course of 5 seconds. Not more. Not less. How would I alter the code to do this? Please help. <!DOCTYPE html> <html> <head> <title></title> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> </head> <body> <canvas id="canvas" width="1350" height="1300" style="background-color: white;"></canvas> <script type='text/javascript'> var canvas = document.getElementById("canvas"); var ctxt = canvas.getContext("2d"); var n1 = 1; var n1_x=49; //Graph x coordinate starting pixel. var n1_y=72;//Graph y coordinate starting pixel. var array_1 = []// array from which y coordinates are taken. Has 1250 elements var ctx = canvas.getContext("2d"); var x=0; var y=0; var Line_position=-1; while(x<=1350)//graph width { ctxt.lineWidth = "0.5"; Line_position=Line_position+1; if(Line_position%5==0) { ctxt.lineWidth = "1.5"; } ctxt.strokeStyle = "black"; ctxt.beginPath(); ctxt.moveTo(x, 0); ctxt.lineTo(x, 1300); ctxt.stroke(); x=x+9.43; } Line_position=-1; while(y<=1300)//graph height { ctxt.lineWidth = "0.5"; Line_position=Line_position+1; if(Line_position%5==0) { ctxt.lineWidth = "1.5"; } ctxt.strokeStyle = "black"; ctxt.beginPath(); ctxt.moveTo(0, y); ctxt.lineTo(1350,y); ctxt.stroke(); y=y+9.43; } drawWave(); function drawWave() { requestAnimationFrame(drawWave); ctx.lineWidth = "1"; ctx.strokeStyle = 'blue'; ctx.beginPath(); ctx.moveTo(n1_x- 1, n1_y+array_1[n1-1]);//move to the pixel position ctx.lineTo(n1_x, n1_y+array_1[n1]);//Draw to the pixel position ctx.stroke(); n1_x=n1_x+0.374;//Incrementing pixel so as to traverse x axis. n1++; } </script> </body> </html> Here is the array: array_1 = [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,72,72,72,72,72,72,72,73,73,74,74,74,74,74,74,74,73,73,73,73,74,74,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,74,74,74,73,73,73,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,71,72,72,72,73,73,73,72,72,72,73,73,73,74,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,72,73,73,73,72,72,72,71,101,71,70,70,70,69,68,68,67,67,66,66,67,67,69,70,72,72,72,73,73,74,73,73,73,73,73,73,73,73,73,74,76,77,76,70,57,40,22,11,11,22,40,57,69,73,73,71,71,71,72,72,73,73,74,74,74,73,72,72,72,72,72,72,72,72,72,72,72,72,71,71,70,70,71,71,71,71,70,70,69,69,69,69,69,69,69,68,68,68,67,67,66,66,65,65,64,63,63,62,62,62,62,62,62,62,62,63,63,64,65,66,67,68,68,69,70,71,72,72,72,73,73,73,73,72,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,73,73,73,73,72,73,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,73,73,74,74,74,74,74,74,73,73,72,73,73,73,74,73,73,72,72,72,73,73,73,72,72,73,73,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,71,70,70,70,70,70,69,69,68,67,67,67,67,68,69,71,72,72,73,73,73,73,74,74,74,74,74,73,73,73,73,75,77,78,76,67,53,35,18,8,10,23,41,58,69,73,72,71,70,71,72,73,73,73,73,73,73,73,73,72,72,73,73,73,73,72,71,71,70,70,71,71,71,71,71,71,71,71,70,70,69,69,69,69,68,68,67,67,67,67,67,66,65,65,65,64,63,62,61,61,61,60,60,60,59,60,60,60,61,62,63,65,66,66,67,68,69,70,71,72,72,72,72,73,73,73,72,72,72,72,72,72,72,73,73,73,73,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,71,71,72,72,73,73,73,72,72,72,72,72,72,73,73,73,73,73,73,73,73,73,72,73,73,73,73,73,73,72,73,73,73,73,73,73,73,72,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,71,71,70,70,69,69,69,68,67,67,66,65,66,66,68,69,70,71,72,72,73,73,73,73,73,73,74,74,74,74,74,74,76,78,78,74,64,48,29,13,5,10,26,45,62,71,73,72,71,71,72,73,73,73,73,73,74,74,74,73,72,72,72,73,73,73,73,73,73,73,72,72,72,72,71,71,71,71,71,71,71,71,71,70,70,69,69,69,69,68,67,66,66,66,66,65,65,64,63,62,62,61,61,60,60,60,60,61,62,62,63,64,65,66,67,68,70,71,72,72,72,72,72,72,73,73,73,73,73,73,73,74,74,75,75,74,74,74,73,73,73,74,73,73,73,73,73,74,74,74,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,73,73,74,74,74,73,73,73,73,73,73,73,73,73,73,72,72,72,72,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,73,73,72,72,71,70,70,70,69,69,68,68,67,67,66,67,67,68,69,70,71,72,73,73,74,74,73,73,73,74,75,75,74,73,73,74,76,78,75,67,52,32,15,5,8,22,41,59,69,73,72,71,70,71,72,72,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,72,72,72,72,71,71,71,70,70,70,70,70,70,70,69,69,69,69,68,68,68,68,67,67,66,65,65,64,64,64,63,62,61,60,60,60,60,60,61,61,62,62,63,64,65,65,66,67,68,69,70,71,71,71,71,71,71,72,72,73,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,72,71,71,71,71,71,71,71,72,72,72,72,72,72,72,72,72,71,71,71,72,72,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,73,73,74,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,72,71,71,71,70,70,70,70,69,69,68,67,67,68,69,71,72,73,73,73,73,73,73,73,73,74,75,75,75,74,74,74,75,77,77,75,67,52,34,18,10,12,26,45,62,71,74,73,72,72,72,73,74,74,74,75,75,74,74,74,74,74,74,74,74,74,73,73,73,73,74,74,73,73,73,73,73,73,73,72,72,71,71,71,71,71,70,70,70,69,69,69,68,68,68,68,67,66,65,64,63,63,62,62,62,63,63,63,63,64,65,66,67,69,69,70,71,72,72,73,73,74,74,74,74,75,75,76,76,74,72,70,70,69,69 ];
I'd probably go about the task something like this. As mentioned in a comment, we need to draw a number of the data-points per-frame. How many we draw depends on the speed that the browser is able to supply an animation frame. I've hard-coded the value to 4, since that seems to work on my machine, but with not much more work you can probably make the code time itself and adjust this value on the fly so that your animation runs for as close as possible to the target time. I had a quick go, but the results were awful, I'll leave that as an exercise in research or thought for the reader. By keeping track of how many frames we've already drawn for the current 'refresh-cycle', we know how far to index into the array for the first point to be drawn for each frame. I've tried to parameterize the code as much as possible, but it's late and I'm tired, I may have overlooked something somewhere. <!doctype html> <html> <head> <script> function byId(id,parent){return (parent == undefined ? document : parent).getElementById(id);} window.addEventListener('load', onDocLoaded, false); function onDocLoaded(evt) { drawBkg(byId('canvas'), 9.43, 5, "0.5", "1.5", "black"); drawCurFrame(); } var dataSamples = [69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,20,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,69,72,72,72,72,72,72,72,73,73,74,74,74,74,74,74,74,73,73,73,73,74,74,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,74,74,74,73,73,73,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,71,72,72,72,73,73,73,72,72,72,73,73,73,74,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,72,73,73,73,72,72,72,71,101,71,70,70,70,69,68,68,67,67,66,66,67,67,69,70,72,72,72,73,73,74,73,73,73,73,73,73,73,73,73,74,76,77,76,70,57,40,22,11,11,22,40,57,69,73,73,71,71,71,72,72,73,73,74,74,74,73,72,72,72,72,72,72,72,72,72,72,72,72,71,71,70,70,71,71,71,71,70,70,69,69,69,69,69,69,69,68,68,68,67,67,66,66,65,65,64,63,63,62,62,62,62,62,62,62,62,63,63,64,65,66,67,68,68,69,70,71,72,72,72,73,73,73,73,72,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,73,73,73,73,72,73,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,73,73,74,74,74,74,74,74,73,73,72,73,73,73,74,73,73,72,72,72,73,73,73,72,72,73,73,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,71,70,70,70,70,70,69,69,68,67,67,67,67,68,69,71,72,72,73,73,73,73,74,74,74,74,74,73,73,73,73,75,77,78,76,67,53,35,18,8,10,23,41,58,69,73,72,71,70,71,72,73,73,73,73,73,73,73,73,72,72,73,73,73,73,72,71,71,70,70,71,71,71,71,71,71,71,71,70,70,69,69,69,69,68,68,67,67,67,67,67,66,65,65,65,64,63,62,61,61,61,60,60,60,59,60,60,60,61,62,63,65,66,66,67,68,69,70,71,72,72,72,72,73,73,73,72,72,72,72,72,72,72,73,73,73,73,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,71,71,72,72,73,73,73,72,72,72,72,72,72,73,73,73,73,73,73,73,73,73,72,73,73,73,73,73,73,72,73,73,73,73,73,73,73,72,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,71,71,70,70,69,69,69,68,67,67,66,65,66,66,68,69,70,71,72,72,73,73,73,73,73,73,74,74,74,74,74,74,76,78,78,74,64,48,29,13,5,10,26,45,62,71,73,72,71,71,72,73,73,73,73,73,74,74,74,73,72,72,72,73,73,73,73,73,73,73,72,72,72,72,71,71,71,71,71,71,71,71,71,70,70,69,69,69,69,68,67,66,66,66,66,65,65,64,63,62,62,61,61,60,60,60,60,61,62,62,63,64,65,66,67,68,70,71,72,72,72,72,72,72,73,73,73,73,73,73,73,74,74,75,75,74,74,74,73,73,73,74,73,73,73,73,73,74,74,74,74,74,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,73,73,74,74,74,73,73,73,73,73,73,73,73,73,73,72,72,72,72,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,73,73,72,72,71,70,70,70,69,69,68,68,67,67,66,67,67,68,69,70,71,72,73,73,74,74,73,73,73,74,75,75,74,73,73,74,76,78,75,67,52,32,15,5,8,22,41,59,69,73,72,71,70,71,72,72,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,72,72,72,72,71,71,71,70,70,70,70,70,70,70,69,69,69,69,68,68,68,68,67,67,66,65,65,64,64,64,63,62,61,60,60,60,60,60,61,61,62,62,63,64,65,65,66,67,68,69,70,71,71,71,71,71,71,72,72,73,73,73,72,72,73,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,72,72,72,72,71,71,71,71,71,71,71,72,72,72,72,72,72,72,72,72,71,71,71,72,72,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,72,72,73,73,73,73,73,72,72,72,73,73,74,73,73,73,73,73,73,73,73,73,73,73,73,72,72,72,72,71,71,71,70,70,70,70,69,69,68,67,67,68,69,71,72,73,73,73,73,73,73,73,73,74,75,75,75,74,74,74,75,77,77,75,67,52,34,18,10,12,26,45,62,71,74,73,72,72,72,73,74,74,74,75,75,74,74,74,74,74,74,74,74,74,73,73,73,73,74,74,73,73,73,73,73,73,73,72,72,71,71,71,71,71,70,70,70,69,69,69,68,68,68,68,67,66,65,64,63,63,62,62,62,63,63,63,63,64,65,66,67,69,69,70,71,72,72,73,73,74,74,74,74,75,75,76,76,74,72,70,70,69,69 ]; function drawBkg(canvasElem, squareSize, numSquaresPerBlock, minorLineWidthStr, majorLineWidthStr, lineColStr) { var nLinesDone = 0; var i, curX, curY; var ctx = canvasElem.getContext('2d'); ctx.clearRect(0,0,canvasElem.width,canvasElem.height); // draw the vertical lines curX=0; ctx.strokeStyle = lineColStr; while (curX < canvasElem.width) { if (nLinesDone % numSquaresPerBlock == 0) ctx.lineWidth = majorLineWidthStr; else ctx.lineWidth = minorLineWidthStr; ctx.beginPath(); ctx.moveTo(curX, 0); ctx.lineTo(curX, canvasElem.height); ctx.stroke(); curX += squareSize; nLinesDone++; } // draw the horizontal lines curY=0; nLinesDone = 0; while (curY < canvasElem.height) { if (nLinesDone % numSquaresPerBlock == 0) ctx.lineWidth = majorLineWidthStr; else ctx.lineWidth = minorLineWidthStr; ctx.beginPath(); ctx.moveTo(0, curY); ctx.lineTo(canvasElem.width, curY); ctx.stroke(); curY += squareSize; nLinesDone++; } } // position that will be treated as 0,0 when drawing our points. var originX=49; var originY=72; function drawSamples(nSamplesToDraw, firstSample, lineWidthStr, lineColourStr) { var can = byId('canvas'); var ctx = can.getContext('2d'); ctx.strokeStyle = lineColourStr; ctx.lineWidth = lineWidthStr; console.log(firstSample); ctx.beginPath(); ctx.moveTo( originX+firstSample-1, dataSamples[firstSample-1]+originY ); for (var i=0; i<nSamplesToDraw; i++) { var curSample = dataSamples[i + firstSample]; ctx.lineTo( originX+firstSample+i, curSample+originY ); } ctx.stroke(); } var curFrame=0; var nPointsPerFrame = 4; function drawCurFrame() { if ((dataSamples.length - (nPointsPerFrame * curFrame)) < nPointsPerFrame) // will we over-run the end of the array of datapoints? { curFrame = 0; // if so, reset drawBkg(byId('canvas'), 9.43, 5, "0.5", "1.5", "black"); } drawSamples(nPointsPerFrame, nPointsPerFrame*curFrame, "1", "blue"); curFrame++; requestAnimationFrame( drawCurFrame ); } </script> <style> #canvas { border: solid 1px black; background-color: #FFFFFF; } </style> </head> <body> <div id='txt'></div> <canvas id="canvas" width="1350" height="1300"></canvas> </body> </html>
Update Now that I see you have provided some more info I get what you want. The problem is you need to draw a fixed number of line segments within time t. As you do not know how long each frame could take you can not rely on a fixed frame rate. The alternative it to just use the current time and save the end time. Get the start time and then each frame draw all the should be drawn until the current time. As the line segments being drawn will not be displayed until the next screen refresh the time you get will be approx 16ms behind so will need to adjust for that. What I have done is keep track of the average frame time and used half that time to estimate when the new canvas update will be displayed. Its a bit pedantic but might as well show how to get a required time as close as possible. If you dont care its a few ms out then just remove the average frame time stuff. You will be at most 30ms off on a slow machine. var canvas; // canvas var ctx; function getCanvas () { // to do // get canvas and context } function drawGrid () { // to do // draw the grid } function drawTimedLine(){ if(canvas === undefined){ // if the canvas not available get it getCanvas(); } // clear the canvas is repeating animation ctx.clearRect(0, 0, canvas.width, canvas.height); drawGrid(); var array_1 = ; // your data // All stuff needed for timed animation. // The frame you render will not be displayed untill the next // vertical refresh which is unknown, Assume it is one frame. var startDelay = 1000; // if Needed time in milliseconds to delay start var endTime; // hold the time that the animation has to end var lastDataPoint; // holds the last point drawn to var timeToDraw = 5 * 1000; // how long the animation should last var repeatAfter = 1 *1000; // if you want to repeat the animatoin var frameCount = 0; // count the frames to get average frame time var startTime; //the start time; var numberPoints = array_1.length; // number of points; var startX = 49; // line starts at var yOffset = 72; // line Y offset var endX = 512; // line ends at. var width = endX - startX; // width var xStep = width / numberPoints; // X step per point var pointsPerMS = numberPoints / timeToDraw; // get how many points per ms should be drawn // function to draw function drawWave() { // variable needed var averageframeTime, timeLeft, i, currentTime; currentTime = new Date().valueOf(); // gets the time in millisecond; if (startTime === undefined) { // Is this the first frame startTime = currentTime; // save the start time; endTime = currentTime + timeToDraw; // workout when the end time is; lastDataPoint = 0; // set the data position to the start; averageframeTime = 0; // no frames counted so frame time is zero } else { frameCount += 1; // count the frames // get the average frame time averageframeTime = (currentTime - startTime) / frameCount; } // get the time this frame // will most likely be displayed // then calculate how long // till the end timeLeft = endTime - Math.min(endTime, currentTime + averageframeTime / 2); // now get where we should // be when the frame is presented pointPos = Math.floor(pointsPerMS * (timeToDraw - timeLeft)); // now draw the points from where we last left of // till the new pos; ctx.lineWidth = 4; ctx.strokeStyle = 'blue'; ctx.beginPath(); ctx.moveTo( // move to first point lastDataPoint * xStep + startX, array_1[lastDataPoint] + yOffset ); // draw each line from the last drawn to the new position for (i = lastDataPoint + 1; i <= pointPos && i < numberPoints; i++) { // Add the line segment ctx.lineTo( i * xStep + startX, array_1[i] + yOffset ); } ctx.stroke(); // execute the render commands lastDataPoint = pointPos; // update the last point if (pointPos < numberPoints) { // are we there yet??? requestAnimationFrame(drawWave); // no so request another frame }else{ // if you want to repeat the animation setTimeout(drawTimedLine , repeatAfter ); } } // start the line animation with delay if needed setTimeout(drawWave,startDelay); } // use this if you want it to start as soon as page is ready. document.addEventListener("DOMContentLoaded",drawTimedLine); // or use if you want it to start when page has images loaded and is ready // document.addEventListener("load",drawTimedLine); I have also added the ability to repeat the animation. If not needed just remove that code My original answer Dont know what the problem is with speed as it runs quite well on my machine. To set up a better start use function startFunction(){ // your code } document.addEventListener("DOMContentLoaded",startFunction); This will wait until the page has loaded and parsed the page. Images and other media may not have loaded but the page is ready to be manipulated. Not sure what you mean with 5 seconds. Assuming you may want the thing to sart in 5 seconds. The following will do that. document.addEventListener("DOMContentLoaded",function() {setTimeout(startFunction,5000);}); I would ask why plot the graph one entry at a time with requestAnimationFrame 1250 is not that many lines to draw. If you add ctx.beginPath() ctx.moveTo(/*first point*/) then loop all points with ctx.moveTo(/*points*/) then ctx.stroke() will run realtime on but the slowest of devices. BTW ctx.lineWidth is a Number not a string. Also you have two context? Use the one context for the canvas. Remove ctxt and just use ctx and finally you don't need to add type='text/javascript' to the script tag as Javascript is the default.
1) It cannot take that long to draw 1000 lines, even 100000 lines won't take more than 10 ms on any decent Browser. Look else where the time is lost. 2) The core issue of your code is that it lacks modularity. Split your code into a few clear functions, group the parameters into a few objects only, name and indent things properly. Below an (incomplete but working) example of how this might look. var cv, ctx; var data = null; var debug = true; // --------------------------------------- // define here all graphic related parameters var gfxParams = { canvasWidth: 600, canvasHeight: 600, gridColor: '#A66', gridSpacing: 10, gridLineWidth: 0.5, gridStrongLinesEvery: 5, lineColor: '#AEB', lastLineColor: '#8A9' // , ... }; // define here all animation related parameters var animationParams = { duration: 5, startTime: -1 } // --------------------------------------- // main // --------------------------------------- window.onload = function() { data = getData(); setupCanvas(data); launchAnimation(); } // --------------------------------------- // function setupCanvas(data) { cv = document.getElementById('cv'); cv.width = gfxParams.canvasWidth; cv.height = gfxParams.canvasHeight; ctx = cv.getContext('2d'); // here you should translate and scale the context // so that it shows your data. } function drawGrid(ctx) { var i = 0, pos = 0, lw = gfxParams.gridLineWidth; ctx.fillStyle = gfxParams.gridColor; var vLineCount = gfxParams.canvasWidth / gfxParams.gridSpacing; for (i = 0; i < vLineCount; i++) { pos = i * gfxParams.gridSpacing; ctx.fillRect(pos, 0, lw, gfxParams.canvasHeight); } var hLineCount = gfxParams.canvasHeight / gfxParams.gridSpacing; for (i = 0; i < hLineCount; i++) { pos = i * gfxParams.gridSpacing; ctx.fillRect(0, pos, gfxParams.canvasWidth, lw); } } function animate() { requestAnimationFrame(animate); var now = Date.now(); // erase screen ctx.clearRect(0, 0, gfxParams.canvasWidth, gfxParams.canvasHeight); // draw grid drawGrid(ctx); // draw lines var lastIndex = getLastDrawnIndex(data, now - animationParams.startTime); drawLines(ctx, data, lastIndex); if (debug) { ctx.save(); ctx.fillStyle = '#000'; ctx.fillText(lastIndex + ' lines drawn. Time elapsed : ' + (now - animationParams.startTime), 10, 10); ctx.restore(); } } // comment function launchAnimation() { requestAnimationFrame(animate); animationParams.startTime = Date.now(); } // comment function getData() { var newData = []; for (var i = 0; i < 500; i++) { newData.push([Math.random() * 600, Math.random() * 600]); } return newData; } // comment function getLastDrawnIndex(data, timeElapsed_ms) { var timeElapsed = timeElapsed_ms / 1000; if (timeElapsed >= animationParams.duration) return data.length - 1; return Math.floor(data.length * timeElapsed / animationParams.duration); } function drawLines(ctx, data, lastIndex) { ctx.strokeStyle = gfxParams.lineColor; // other ctx setup here. for (var i = 0; i < lastIndex - 1; i++) { drawLine(ctx, data[i], data[i + 1]); } ctx.strokeStyle = gfxParams.lastLineColor; drawLine(ctx, data[lastIndex - 1], data[lastIndex]); } function drawLine(ctx, p1, p2) { ctx.beginPath(); ctx.moveTo(p1[0], p1[1]); ctx.lineTo(p2[0], p2[1]); ctx.stroke(); } <canvas id='cv'></canvas>
Adding video to Javascript Canvas
Is it possible to add a background video that will loop over and over to a HTML5 Canvas? This is that work I have so far just want to add a simple video that will play to the background. I am able to add video to the HTML with the video tag but want it played on the canvas itself. <canvas id="ex1" width="525" height="200" style="border: 5px solid black;" ></canvas> <p id="text"> Increase/Decrease Speed</p> <input type="button" value="+" id="btnAdd"> <input type="button" value="-" id="btnSub"> <script> var x = 0; var y = 15; var speed = 10; var isRight = true; document.getElementById('text').innerText = speed; document.getElementById('btnAdd').addEventListener('click', function (event) { if (isRight) speed++; else speed--; document.getElementById('text').innerText = speed; }); document.getElementById('btnSub').addEventListener('click', function (event) { if (isRight) speed--; else speed++; document.getElementById('text').innerText = speed; }); function animate() { reqAnimFrame = window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || window.msRequestAnimationFrame || window.oRequestAnimationFrame; reqAnimFrame(animate); x += speed; if (x <= 0 || x >= 475) { speed = -speed; isRight = !isRight; } document.getElementById('text').innerText = speed; draw(); } function draw() { var canvas = document.getElementById("ex1"); var context = canvas.getContext("2d"); context.clearRect(0, 0, 525, 200); context.fillStyle = "#ff00ff"; context.fillRect(x, y, 40, 40); } animate(); </script>
A frame currently running in a video element can be copied to canvas. Using setInterval we have to regularly sample the video element and copy it to canvas. It can be used to do interesting stuff. From Mozilla drawImage The first parameter can be any element to draw into the context; the specification permits any image element (that is, <img>, <canvas>, and <video>). Here is a boiler plater code sample - var videoElement, canvasContext; videoElement.addEventListener('play', function(){ copyCurrentFrameIntoCanvas(this); setInterval(copyCurrentFrameIntoCanvas,10,this); },false); function copyCurrentFrameIntoCanvas(videoElement) { canvasContent.drawImage(videoElement,0,0,<width>,<height>); } You need to initialise the videoElement and canvasContent appropriately which i think you know already. Also replace <width> and <height> placeholders appropriately.
You can create an off-screen video element so you won't have to deal with CSS or cause extra reflowing. To create an off-screen video element is simple: /// element var video = document.createElement('video'); /// set video elemet size video.width = 640; video.height = 360; /// setup with auto preload and loop video.preload = 'auto'; video.loop = true; Now you can attach an event handler so you start drawing when the video is ready to be played: video.addEventListener('canplay', start, false); Now set the source of the video. You need to check what types the browser can play by using the video.canPlayType('<mime-type-here>') method but for simplicity we set the source directly: video.src = 'link/to/video.ogv'; In the handler we can now update the video. As the requestAnimationFrame tries to update 60 times per second we can reduce it to half as video is rarely above 30 FPS (US, 25 in Europe): function start() { /// get context from canvas (canvas not shown in example) var ctx = canvas.getContext('2d'), toggle = true; /// this is used to reduce FPS /// start video video.play(); /// start loop requestAnimationFrame(loop); function loop() { /// reduce frame-rate to half toggle = !toggle; if (toggle) { requestAnimationFrame(loop); return; } /// draw video frame ctx.draw(video, 0, 0); requestAnimationFrame(loop); } } Disclaimer: untested but you see the main steps. The code should create the video element and auto-start it when it's ready. Then it will run in a loop and draw the video frame to canvas every 30 FPS (or so). Note: Safari browser do not support drawImage with a video element in iOS (at the moment writing this answer).
HTML5 canvas continuously stroking lines
I want to draw some continuously growing lines in HTML5 and Javascript. Here is what I want to do: A point located at the center of my screen will have 3 lines growing (120 degree to each other) to a certain length, say 50 pix, then each of this 3 vertex will become a new center and have another 3 lines. (I couldnt post images due to low reputation I have, hopefully you know what I mean abt the image here...) I already written the function to have a array of all the points I need as the centers, starting from the center of my screen. I am thinking to write a loop over this array to draw the lines. I DO NOT want to directly use the stroke so that the line just appears on the screen. I want to have something like the the lines are drawn bit by bit (bad english here, please excuse my english) until it reaches the pre-defined length. However my code dont work quite well here, it only displays all the center points and only the last center point has the movement to have the 3 lines to grow... I need to know the correct way to do this... many thanks in advance! (please ignore the variable time or startTime in my code... ) <script> window.requestAnimFrame = (function(callback) { return window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(callback) { window.setTimeout(callback, 1000 / 60); }; })(); var canvas = document.getElementById('myCanvas'); canvas.width= window.innerWidth; canvas.height= window.innerHeight; var context = canvas.getContext('2d'); var totalLength = 50; var centreSet = new Array(); var counter = 0; var centre = { x: canvas.width / 2, y: canvas.height / 2, }; var myLine = { length : 0, color : 'grey', lineWidth : 0.5, }; function drawLine(centre, context, mylength) { context.beginPath(); context.moveTo(centre.x, centre.y); context.lineTo(centre.x, centre.y - mylength); context.moveTo(centre.x, centre.y); context.lineTo(centre.x - 0.866 * mylength, centre.y + mylength/2); context.moveTo(centre.x, centre.y); context.lineTo(centre.x + 0.866 * mylength, centre.y + mylength/2); context.lineWidth = myLine.lineWidth; context.strokeStyle = myLine.color; context.closePath(); context.stroke(); } function startAnimate(centre, canvas, context, startTime, mylength) { // update var time = (new Date()).getTime() - startTime; var linearSpeed = 5; // pixels / second var newX = linearSpeed / 10; if(mylength < totalLength) { mylength = mylength + newX; // clear //context.clearRect(0, 0, canvas.width, canvas.height); drawLine(centre, context, mylength); // request new frame requestAnimFrame(function() { startAnimate(centre, canvas, context, startTime, mylength); }); } } function animate(centre, canvas, context, startTime){ //create array to have all the center points centreSet = getCentres(); for (var i = 0; i < centreSet.length; i++){ //pass the x and y values in a object for each center we have in the array centre.x = str2x(centreSet[i]); centre.y = str2y(centreSet[i]); startAnimate(centre, canvas, context, startTime, 0); } } setTimeout(function() { var startTime = (new Date()).getTime(); animate(centre, canvas, context, startTime); }, 1000); I just edited your code, I added the following part: var length = 0; for(var i = 0; i < 380; i++){ window.setTimeout(function() {drawFrame(length);},16.67); length = length + 0.25; } I expect the screen appears to draw the incremental lines bit by bit until it reaches the length I want. However, it seems like the whole incremental process is not shown and it only shows the finished drawing. Can anyone tell me why?
Regarding your followup question about why your animation loop fails By putting your setTimeout in a for-loop, each new setTimeout is cancelling the previous setTimeout. So you’re just left with the very last setTimeout running to completion. In an animation loop, you typically do 3 things during each "frame": Change some data to reflect how the new frame is different from the previous frame. Draw the frame. Test if the animation is complete. If not, do another frame (go to #1). The setTimeout function is used to do the last part of #3 (do another frame) So setTimeout is really acting as your animation loop. --- Your for-loop is not needed. This is how you would restructure your code to follow this pattern: var length=0; var maxLength=50; function draw(){ // make the line .25 longer length=length+.25; // draw drawFrame(length); // test if the line is fully extended // if not, call setTimeout again // setTimeout(draw,100) will call this same draw() function in 100ms if(length<maxLength){ setTimeout(draw,100); } }
[Edited: to include spawning of child objects after lines reach terminal distance] In your code you were not spawning new center points when the lines reached their maximum extension. I would suggest that each of your centre objects have at least this much information in order to spawn a new set of centre objects when their lines reach terminal length: var newCentrePoint={ x:x, y:y, maxLength:newMaxLength, growLength:growLength, currentLength:0, isActive:true } The x,y are the centerpoint’s coordinates. maxLength is the maximum extension of the 3 lines before they are terminated. growLength is the amount by which each line will grow in each new frame. currentLength is the current length of the line. isActive is a flag indicating if this point is growing lines (true) or if it’s terminated (false) Then when each line reaches terminal length you can spawn a new set of lines like this: // spawns 3 new centre points – default values are for testing function spawn(point,newMaxLength,newColor,growLength,newLineWidth){ var max=newMaxLength||point.maxLength/2; var color=newColor|| (colors[++colorIndex%(colors.length)]); var grow=growLength||point.growLength/2; var lw=newLineWidth||point.lineWidth-1; // new center points are spawned at the termination points of the 3 current lines newPoint((point.x),(point.y-point.maxLength),max,color,grow,lw); newPoint((point.x-0.866*point.maxLength),(point.y+point.maxLength/2),max,color,grow,lw); newPoint((point.x+0.866*point.maxLength),(point.y+point.maxLength/2),max,color,grow,lw); } // creates a new point object and puts in the centreSet array for processing function newPoint(x,y,newMaxLength,newColor,growLength,newLineWidth){ var newPt={ x:x, y:y, maxLength:newMaxLength, color:newColor, lineWidth:newLineWidth, growLength:growLength, currentLength:0, isActive:true } centreSet.push(newPt); } Here is code and a Fiddle: http://jsfiddle.net/m1erickson/Vc8Gf/ <!doctype html> <html> <head> <link rel="stylesheet" type="text/css" media="all" href="css/reset.css" /> <!-- reset css --> <script type="text/javascript" src="http://code.jquery.com/jquery.min.js"></script> <style> body{ background-color: ivory; } canvas{border:1px solid red;} </style> <script> $(function(){ var canvas=document.getElementById("canvas"); var context = canvas.getContext('2d'); // colors var colors=["red","blue","gold","purple","green"]; var colorIndex=0; // var centreSet=[] var generations=1; // seed point newPoint(canvas.width/2,canvas.height/2,100,"red",15); // start draw(); // function draw(){ // context.clearRect(0,0,canvas.width,canvas.height); // for(var i=0;i<centreSet.length;i++){ // var centre=centreSet[i]; // if(centre.isActive){ // centre.currentLength+=centre.growLength; // if(centre.currentLength>=centre.maxLength){ centre.isActive=false; centre.currentLength=centre.maxLength; spawn(centre); } } // drawLines(centre); } // if(generations<120){ setTimeout(draw,500); }else{ context.font="18pt Verdana"; context.fillText("Finished 120 generations",40,350); } } function spawn(point,newMaxLength,newColor,growLength,newLineWidth){ var max=newMaxLength||point.maxLength/2; var color=newColor|| (colors[++colorIndex%(colors.length)]); var grow=growLength||point.growLength/2; var lw=newLineWidth||point.lineWidth-1; newPoint((point.x),(point.y-point.maxLength),max,color,grow,lw); newPoint((point.x-0.866*point.maxLength),(point.y+point.maxLength/2),max,color,grow,lw); newPoint((point.x+0.866*point.maxLength),(point.y+point.maxLength/2),max,color,grow,lw); generations++; } function newPoint(x,y,newMaxLength,newColor,growLength,newLineWidth){ var newPt={ x:x, y:y, maxLength:newMaxLength, color:newColor, lineWidth:newLineWidth, growLength:growLength, currentLength:0, isActive:true } centreSet.push(newPt); } function drawLines(centre) { var length=centre.currentLength; // context.beginPath(); context.moveTo(centre.x, centre.y); context.lineTo(centre.x, centre.y - length); // context.moveTo(centre.x, centre.y); context.lineTo(centre.x - 0.866 * length, centre.y + length/2); // context.moveTo(centre.x, centre.y); context.lineTo(centre.x + 0.866 * length, centre.y + length/2); // context.strokeStyle=centre.color; context.lineWidth = centre.lineWidth; context.stroke(); } }); // end $(function(){}); </script> </head> <body> <canvas id="canvas" width=400 height=400></canvas> </body> </html>