noisy line between two specific points P5.js - javascript
I'm trying to draw a noisy line (using perlin noise) between two specific points.
for example A(100, 200) and B(400,600).
The line could be a points series.
Drawing random noisy line is so clear but I dont know how can I calculate distance specific points.
working of P5.js.
I don't have any code written yet to upload.
Please can anyone help me?
I tried to add sufficient comments that you would be able to learn how such a thing is done. There are a number of things that you should make yourself aware of if you aren't already, and it's hard to say which if these you're missing:
for loops
drawing lines using beginShape()/vertex()/endShape()
Trigonometry (in this case sin/cos/atan2) which make it possible to find angles and determine 2d offsets in X and Y components at a given angle
p5.Vector() and its dist() function.
// The level of detail in the line in number of pixels between each point.
const pixelsPerSegment = 10;
const noiseScale = 120;
const noiseFrequency = 0.01;
const noiseSpeed = 0.1;
let start;
let end;
function setup() {
createCanvas(400, 400);
noFill();
start = createVector(10, 10);
end = createVector(380, 380);
}
function draw() {
background(255);
let lineLength = start.dist(end);
// Determine the number of segments, and make sure there is at least one.
let segments = max(1, round(lineLength / pixelsPerSegment));
// Determine the number of points, which is the number of segments + 1
let points = 1 + segments;
// We need to know the angle of the line so that we can determine the x
// and y position for each point along the line, and when we offset based
// on noise we do so perpendicular to the line.
let angle = atan2(end.y - start.y, end.x - start.x);
let xInterval = pixelsPerSegment * cos(angle);
let yInterval = pixelsPerSegment * sin(angle);
beginShape();
// Always start with the start point
vertex(start.x, start.y);
// for each point that is neither the start nor end point
for (let i = 1; i < points - 1; i++) {
// determine the x and y positions along the straight line
let x = start.x + xInterval * i;
let y = start.y + yInterval * i;
// calculate the offset distance using noice
let offset =
// The bigger this number is the greater the range of offsets will be
noiseScale *
(noise(
// The bigger the value of noiseFrequency, the more erretically
// the offset will change from point to point.
i * pixelsPerSegment * noiseFrequency,
// The bigger the value of noiseSpeed, the more quickly the curve
// fluxuations will change over time.
(millis() / 1000) * noiseSpeed
) - 0.5);
// Translate offset into x and y components based on angle - 90°
// (or in this case, PI / 2 radians, which is equivalent)
let xOffset = offset * cos(angle - PI / 2);
let yOffset = offset * sin(angle - PI / 2);
vertex(x + xOffset, y + yOffset);
}
vertex(end.x, end.y);
endShape();
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/p5.js/1.4.0/p5.js"></script>
This code makes jaggy lines, but they could be smoothed using curveVertex(). Also, making the line pass through the start and end points exactly is a little tricky because the very next point may be offset by a large amount. You could fix this by making noiseScale very depending on how far from an endpoint the current point is. This could be done by multiplying noiseScale by sin(i / points.length * PI) for example.
Related
Animating a fractal tree inside a Javascript Canvas
After I saw a video from the Coding Train on youtube about fractal trees, I tried to build one myself. Which worked great and I played with some variables to get different results. I would love to see the tree moving like it got hit by some wind. I tried different approaches like rotating the branches a little bit or some minor physics implementations but that failed miserably. So my question is: What would be the best approach to render a fractal tree and give it some sort of "life" like little shakes from wind. Is there some sort of good reference ? Do I need physics ? -> If so where do I have to look ? If not -> How could I fake such an effect? I am glad about every help I can get. Source for the idea: https://www.youtube.com/watch?v=0jjeOYMjmDU
Tree in the wind. The following are some short points re bending a branch in the wind. As the whole solution is complex you will have to get what you can from the code. The code includes a seeded random number functions. A random recursive tree renderer, a poor quality random wind generator, all drawn on canvas using an animation loop. Wind To apply wind you need to add a bending force to each branch that is proportional to the angle of the branch to the wind. So if you have a branch in direction dir and a wind in the direct wDir the amount of scaling the bending force needs is var x = Math.cos(dir); // get normalize vector for the branch var y = Math.sin(dir); var wx = Math.cos(wDir); // get normalize vector for the wind var wy = Math.sin(wDir); var forceScale = x * wy - y * wx; The length of the branch also effects the amount of force to include that you lengthen the vector of the branch to be proportional to its length var x = Math.cos(dir) * length; // get normalize vector for the branch var y = Math.sin(dir) * length; var wx = Math.cos(wDir); // get normalize vector for the wind var wy = Math.sin(wDir); var forceScale = x * wy - y * wx; Using this method ensures that the branches do not bend into the wind. There is also the thickness of the branch, this is a polynomial relationship related to the cross sectional area. This is unknown so is scaled to the max thickness of the tree (an approximation that assumes the tree base can not bend, but the end branches can bend a lot.) Then the elastic force of the bent branch will have a force that moves the branch back to its normal position. This acts like a spring and is very much the same as the wind force. As the computational and memory load would start to overwhelm the CPU we can cheat and use the wind to also recoil with a little bit of springiness. And the tree. The tree needs to be random, yet being fractal you don't want to store each branch. So you will also need a seeded random generator that can be reset at the start of each rendering pass. The tree is rendered randomly with each iteration but because the random numbers start at the same seed each time you get the same tree. The example Draws random tree and wind in gusts. Wind is random so tree may not move right away. Click tree image to reseed the random seed value for the tree. I did not watch the video, but these things are quite standard so the recursive function should not be to far removed from what you may have. I did see the youTube cover image and it looked like the tree had no randomness. To remove randomness set the leng, ang, width min, max to be the same. eg angMin = angMax = 0.4; will remove random branch angles. The wind strength will max out to cyclone strength (hurricane for those in the US) to see the max effect. There are a zillion magic numbers the most important are as constants with comments. const ctx = canvas.getContext("2d"); // click function to reseed random tree canvas.addEventListener("click",()=> { treeSeed = Math.random() * 10000 | 0; treeGrow = 0.1; // regrow tree }); /* Seeded random functions randSeed(int) int is a seed value randSI() random integer 0 or 1 randSI(max) random integer from 0 <= random < max randSI(min, max) random integer from min <= random < max randS() like Math.random randS(max) random float 0 <= random < max randS(min, max) random float min <= random < max */ const seededRandom = (() => { var seed = 1; return { max : 2576436549074795, reseed (s) { seed = s }, random () { return seed = ((8765432352450986 * seed) + 8507698654323524) % this.max }} })(); const randSeed = (seed) => seededRandom.reseed(seed|0); const randSI = (min = 2, max = min + (min = 0)) => (seededRandom.random() % (max - min)) + min; const randS = (min = 1, max = min + (min = 0)) => (seededRandom.random() / seededRandom.max) * (max - min) + min; /* TREE CONSTANTS all angles in radians and lengths/widths are in pixels */ const angMin = 0.01; // branching angle min and max const angMax= 0.6; const lengMin = 0.8; // length reduction per branch min and max const lengMax = 0.9; const widthMin = 0.6; // width reduction per branch min max const widthMax = 0.8; const trunkMin = 6; // trunk base width ,min and max const trunkMax = 10; const maxBranches = 200; // max number of branches const windX = -1; // wind direction vector const windY = 0; const bendability = 8; // greater than 1. The bigger this number the more the thin branches will bend first // the canvas height you are scaling up or down to a different sized canvas const windStrength = 0.01 * bendability * ((200 ** 2) / (canvas.height ** 2)); // wind strength // The wind is used to simulate branch spring back the following // two number control that. Note that the sum on the two following should // be below 1 or the function will oscillate out of control const windBendRectSpeed = 0.01; // how fast the tree reacts to the wing const windBranchSpring = 0.98; // the amount and speed of the branch spring back const gustProbability = 1/100; // how often there is a gust of wind // Values trying to have a gusty wind effect var windCycle = 0; var windCycleGust = 0; var windCycleGustTime = 0; var currentWind = 0; var windFollow = 0; var windActual = 0; // The seed value for the tree var treeSeed = Math.random() * 10000 | 0; // Vars to build tree with var branchCount = 0; var maxTrunk = 0; var treeGrow = 0.01; // this value should not be zero // Starts a new tree function drawTree(seed) { branchCount = 0; treeGrow += 0.02; randSeed(seed); maxTrunk = randSI(trunkMin, trunkMax); drawBranch(canvas.width / 2, canvas.height, -Math.PI / 2, canvas.height / 5, maxTrunk); } // Recusive tree function drawBranch(x, y, dir, leng, width) { branchCount ++; const treeGrowVal = (treeGrow > 1 ? 1 : treeGrow < 0.1 ? 0.1 : treeGrow) ** 2 ; // get wind bending force and turn branch direction const xx = Math.cos(dir) * leng * treeGrowVal; const yy = Math.sin(dir) * leng * treeGrowVal; const windSideWayForce = windX * yy - windY * xx; // change direction by addition based on the wind and scale to // (windStrength * windActual) the wind force // ((1 - width / maxTrunk) ** bendability) the amount of bending due to branch thickness // windSideWayForce the force depending on the branch angle to the wind dir += (windStrength * windActual) * ((1 - width / maxTrunk) ** bendability) * windSideWayForce; // draw the branch ctx.lineWidth = width; ctx.beginPath(); ctx.lineTo(x, y); x += Math.cos(dir) * leng * treeGrowVal; y += Math.sin(dir) * leng * treeGrowVal; ctx.lineTo(x, y); ctx.stroke(); // if not to thing, not to short and not to many if (branchCount < maxBranches && leng > 5 && width > 1) { // to stop recusive bias (due to branch count limit) // random select direction of first recusive bend const rDir = randSI() ? -1 : 1; treeGrow -= 0.2; drawBranch( x,y, dir + randS(angMin, angMax) * rDir, leng * randS(lengMin, lengMax), width * randS(widthMin, widthMax) ); // bend next branch the other way drawBranch( x,y, dir + randS(angMin, angMax) * -rDir, leng * randS(lengMin, lengMax), width * randS(widthMin, widthMax) ); treeGrow += 0.2; } } // Dont ask this is a quick try at wind gusts // Wind needs a spacial component this sim does not include that. function updateWind() { if (Math.random() < gustProbability) { windCycleGustTime = (Math.random() * 10 + 1) | 0; } if (windCycleGustTime > 0) { windCycleGustTime --; windCycleGust += windCycleGustTime/20 } else { windCycleGust *= 0.99; } windCycle += windCycleGust; currentWind = (Math.sin(windCycle/40) * 0.6 + 0.4) ** 2; currentWind = currentWind < 0 ? 0 : currentWind; windFollow += (currentWind - windActual) * windBendRectSpeed; windFollow *= windBranchSpring ; windActual += windFollow; } requestAnimationFrame(update); function update() { ctx.clearRect(0,0,canvas.width,canvas.height); updateWind(); drawTree(treeSeed); requestAnimationFrame(update); } body { font-family : arial; } <canvas id="canvas" width="250" heigth="200"></canvas> Click tree to reseed. Update I just noticed that the wind and branch length are absolute thus drawing the tree on a larger canvas will create a bending force too great and the branches will bend past the wind vector. To scale the sim up either do it via a global scale transform, or reduce the windStrength constant to some smaller value. You will have to play with the value as its a 2nd order polynomial relation. My guess is multiply it with (200 ** 2) / (canvas.height ** 2) where the 200 is the size of the example canvas and the canvas.height is the new canvas size. I have added the calculations to the example, but its not perfect so when you scale you will have to change the value windStrength (the first number) down or up if the bending is too far or not enough.
Animated footsteps in html svg
Is it possible to create small animated footsteps in HTML SVG or Canvas. I am just starting out with these technologies, and it is very much necessary for a small project i am working on. My current idea was to create and use a "gif" of animated footsteps. But i would like to know if it can be achieved in any other way through HTML/CSS/JS PS : The footsteps i keep mentioning should be similar to the footsteps that appear on the "Marauders Map" in harry potter Movies. Thanks for any help
Walk about. I have never seen the movie you talk about so I am guessing what you are after. To do it on the canvas is easy, and I am more than happy to write an example of how it's done for you. Draw a foot You need an image of a foot, or some way to draw a foot. I used a set of shapes I happened to have to draw a foot. Then create a function that draws the foot at a location and in a direction. You also need to specify if its a left or right step. If you have a foot image you want to use just replace the code in the drawFoot function after the comment // draw the foot... with ctx.drawImage(footImage,-footImage.width / 2, -footImage.height / 2); You may have to scale the image, and the foot image should be of the left foot toes pointing to the right of screen Path The path to walk along is just an array of points, [x,y,x,y...] in order that define the path to travel along, They are just a guide as each foot step is a fixed distance apart and the points can be any distance appart. Animate Each step is some time apart (demo is 500ms or half a second). I use setTimeout to call the function to draw the next step. When the function is called I find the next position on the path and draw the next foot step. When the walk has gone past the end of the path I clear the canvas and restart. Demo It's self explanatory in the demo. I track two positions on the path, one is where the foot step is, and the other is just ahead and used to get the direction the foot should be drawn. The function that gets the distance along the path is recursive because the path points are not uniform in distance apart, so may have to skip line segments if the distance to travel is greater than the current or next or few line segments. // create a canvas and add it to the DOM var createImage=function(w,h){var i=document.createElement("canvas");i.width=w;i.height=h;i.ctx=i.getContext("2d");return i;} var canvas = createImage(1024,512); var ctx = canvas.ctx; document.body.appendChild(canvas); // shapes for the foot. Left foot const foot = [ [50.86759744022923,-21.798383338076917,54.16000854997335,-23.917474843549847,57.778065334829385,-25.310771525314685,61.579706305344985,-24.823762596975733,65.0168431653022,-22.69100336700319,65.22736925598322,-19.777045647294724,63.09649708656406,-16.826669881834157,59.66512409715465,-15.356252875428147,56.12216018899968,-14.92259970211097,52.06404407417057,-16.231839553378,50.2945579442406,-18.938589556263246], [60.12039562389232,-12.45714817900668,63.92394094034509,-14.994440399059425,68.75013312287521,-15.737202635924493,73.10937504616481,-14.878459739068003,76.36064492186433,-12.559833524837757,77.6863729180915,-9.181208344485064,75.4625672565435,-5.673231626251427,71.79886053681197,-3.7381471592011817,66.8618942467243,-3.4903609701416993,62.29264392518654,-5.1248680438596885,58.98975517513061,-8.760952968033395], [65.57414109270752,1.1797411270282658,69.37768640916029,-1.3575510930244814,74.20387859169041,-2.1003133298895467,78.56312051498001,-1.241570433033059,81.81439039067953,1.0770557811971881,83.14011838690669,4.455680961549877,80.9163127253587,7.963657679783514,77.25260600562717,9.898742146833756,72.3156397155395,10.146528335893239,67.74638939400174,8.512021262175251,64.44350064394581,4.875936338001546], [65.89915812212375,15.917267748549033,69.97688522977245,12.635767809535894,76.25232402290966,11.736330263416008,81.47328014710077,12.477566678331382,86.09545897877996,15.579569438835726,86.99032987455637,21.425830739951824,83.82647235747945,24.97297628549917,79.18353918133074,27.064789354098487,73.69821507617947,27.23418460503707,68.46309469655478,24.972976285499172,64.88602415530316,20.55351481505123], [58.48881251239855,36.09589759380796,65.7080603859302,29.82038065752831,74.19222753183148,28.331948884004674,82.75081761131048,31.085582242549528,88.10923922724437,34.28575070762116,91.45825273720305,41.65358042953028,87.067323913035,47.45853718012533,79.77391671356942,50.28659303297933,71.73628428966856,50.06332546564875,64.14518700042888,47.45853718012533,60.12637078847845,42.69549574373964], [-73.48953442580058,20.579088801900756,-80.48690958722098,13.959950657259256,-81.93681598574045,6.269142804242765,-81.49554012532147,-1.6107832746678348,-77.90207999991593,-9.181527272091415,-71.6611785393426,-14.98115303708649,-64.60076477263831,-17.880965834138024,-57.35123278004056,-19.078714598132443,-50.09111381970131,-19.902008890566687,-42.96765884171789,-19.08249722231963,-35.655087439697766,-18.51514254492067,-28.90987071615029,-18.578181953551955,-21.74774447703016,-19.60773669210723,-14.309090001741001,-20.364210136314323,-6.933479190821032,-21.688037717705875,0.33383104043200396,-22.888118253462963,7.772483543580581,-23.77067027395373,15.274173171058239,-24.338024951681817,22.460665755024706,-24.590182586206954,29.710197747622452,-23.707630865368966,36.8557533915613,-22.565778766908277,44.16832856198768,-19.28772830000901,51.48089996424725,-14.370654426435763,56.713170880643965,-7.499358885625703,60.24016927073608,-0.41616112008138906,61.75311234056134,6.518193267525415,62.38350642684393,13.515567625813127,61.67231220934209,20.50500542283382,59.08769637136125,27.56541945045329,54.35974072401175,34.87799085169213,48.686193947196124,39.41682827314464,41.87793781501736,42.379680478815025,34.313208779263185,43.26223219965301,27.063676786665432,42.25360166155246,19.625026568173826,38.28211891778152,13.457927624759604,31.720792179781256,9.486440924356895,25.290772320002496,6.019273449215143,18.7346738223298,0.21964785513691965,13.565442314564446,-5.832135373466421,9.467880753530935,-12.632472285211591,8.882365666622222,-19.188577231399584,11.277861070017005,-26.31203040678842,14.49287091019486,-32.99420772170462,17.833959567652954,-39.2981485848331,20.670732956060768,-45.854247082486715,23.192309301312157,-52.47338498877162,24.89437333435685,-59.5968381641068,25.020452151619416,-67.33461307855538,23.697386555044208], ] const footScale = 0.2; // how big the foot is const stepLen = 60; // distance between steps var stepCount = 0; // current set num so left and right can be known var stepTime = 500; // time ms between steps // path to walk const path = [56.20191403126277,162.4451015086347,83.38688266344644,172.80127602121507,107.98280549274708,192.86637096042372,121.57528916149568,221.34586055208607,124.81159479691195,256.2979614145819,141.64038410107662,293.8391067854107,168.82535143857336,311.9624183437419,203.77745230106916,336.5583411729056,238.0822920364817,344.9727358249879,278.2124819156436,341.0891690624884,316.40088841355566,329.43846877498976,343.58585575105235,310.6678960895754,370.77082308854904,275.7157952270795,359.12012280105046,244.64726112708325,344.23311687813566,207.10611575625444,355.23655603855093,168.9177092583423,394.0722236635463,137.2019140312628,438.0859803052077,137.84917515834604,487.27782596353507,174.0957982750084,507.9901820301992,221.9931216791693,513.1682710468652,269.243183956247,500.87030963228347,318.43502961457443,480.1579535656192,354.68165273123674,453.62744426338134,396.86543776550707,414.1445200788371,427.9340428271046,372.7198079555102,447.3518767949864,320.2916566617712,442.173787778395,272.39433325761024,427.9340429825634,218.02439858261675,441.5265266513118,185.66134222845398,472.59506075130815,160.418158272207,514.6670340117198,168.2291881671332,557.5405924870362,200.59229872785795,598.9654951914354,232.9553551615553,627.4449850627141,273.08554504131894,651.3936467669101,320.3356073183967,663.0443470544095,368.2329307225576,663.6916081814927,417.4247763808851,649.4518633856611,460.7912718954633,626.150462810664,509.33585642670744,593.1401453294179,530.6954736204549,556.8935222127556,559.9273870166451,517.9197870310509,582.4287517306153,484.11964343037323,597.1560832290169,459.03222473087396,621.0274949086466,438.11039022321154,651.3689440081158,429.43667093843567,686.3731150817684,432.05029606733103,726.1878666750503,421.6902139845064,748.5744620042316,397.8927935245363,778.6337708564557,367.5111094723503,792.6287871481064,335.0802046803193,795.4641381478963,294.8623601925252,790.3177294792127,255.26933447013639,776.3228370821212,225.344431214269,746.3711518226298,192.73203550406103,713.7991149596966,199.06094085265394,674.3068624609349,207.5062077919911,638.4763261746227,190.31310645331482,613.6509940547375,146.74931837304698,621.5992452450397,103.454341485492,665.5124383180124,60.96567428151931,716.1845355322713,48.49595708249788,763.6383682758693,51.23726133320403,810.1045243122669,71.53440096982465,842.407749982487,97.97907893142005,879.5993779794437,131.14717279570036,903.6790094213126,175.24174017377706,915.9471803279671,219.31612086267396,902.1335310600084,270.1561321514687,880.1365756762476,315.0232456643523,884.5103070340778,370.89556334366307,909.7723644212043,407.9691345807976,947.0675376346722,439.8492118274288,990.6429384281869,439.26727537005956,1036.8675099917996,414.23364852545194,1070.3264506272462,387.0500494883014,1100.6074853525497,351.4546920217324,1119.943854180156,306.7958514306488,1128.5371035594999,259.67124425611814,1122.6651029017848,208.79760059460207,1106.8898009575623,162.16340658911932,1082.4004208812885,108.81054339506417,1050.2046949092428,81.72759371897288,1016.627194271211,46.42875173061529]; const pLen = path.length; // fix the path so it starts at zero for(var i = 2; i < pLen; i += 2){ path[i] -= path[0]; path[i+1] -= path[1]; } path[0] = path[1] = 0; // tracks the foot pos var pos = { x : path[0], y : path[1], index : 0, }; // tracks the foot pointing to pos var pos1 = { x : path[0], y : path[1], index : 0, }; // get a distance alone the path function getDistOnPath(dist,pos){ var nx = path[(pos.index + 2) % pLen] - pos.x; var ny = path[(pos.index + 3) % pLen] - pos.y; var d = Math.hypot(nx, ny); if(d > dist){ pos.x += (nx / d) * dist; pos.y += (ny / d) * dist; return pos; } dist -= d; pos.index += 2; pos.x = path[pos.index % pLen]; pos.y = path[(pos.index + 1) % pLen]; return getDistOnPath(dist, pos); } function drawFoot(x,y,dir,left){ var i,j,shape; var xdx = Math.cos(dir) * footScale; var xdy = Math.sin(dir) * footScale; if(left){ ctx.setTransform(xdx, xdy, -xdy, xdx, x + xdy * 50, y - xdx * 50); ctx.rotate(-0.1); // make the foot turn out a bit }else{ ctx.setTransform(xdx, xdy, -xdy, xdx, x - xdy * 50, y + xdx * 50); ctx.rotate(-0.1); // make the foot turn out a bit ctx.scale(1,-1); // right foot needs to be mirrored } // draw the foot as a set of paths points ctx.beginPath(); for(j = 0; j < foot.length; j ++){ shape = foot[j]; i = 0; ctx.moveTo(shape[i++],shape[i++]); while(i < shape.length){ ctx.lineTo(shape[i++],shape[i++]); } ctx.closePath(); } ctx.fill(); } ctx.setTransform(1,0,0,1,0,0); ctx.clearRect(0,0,canvas.width,canvas.height); pos1 = getDistOnPath(stepLen/10,pos1); // put the second pos infront so that a direction can be found function drawStep(){ if(pos.index > pLen){ // if past end of path clear and restart ctx.setTransform(1,0,0,1,0,0); ctx.clearRect(0,0,canvas.width,canvas.height); pos.index = 0; pos1.index = 0; pos1.x = pos.x = path[0]; pos1.y = pos.y = path[1]; pos1 = getDistOnPath(stepLen/10,pos1); } pos = getDistOnPath(stepLen,pos); pos1 = getDistOnPath(stepLen,pos1); drawFoot(pos.x,pos.y,Math.atan2(pos1.y - pos.y, pos1.x - pos.x),(stepCount++) % 2 === 0); setTimeout(drawStep,stepTime); } drawStep(); Note some of the code is ES6 and will require babel (or equivilent) to run on legacy browsers.
JavaScript canvas, scale between two points on chart/graph?
So I've built a small graph application with JavaScript to help me practice using the canvas. I've spent the last 10 hours trying to scale between two points on the X-Axis and can't for the life of me figure it out. I've learned that to scale you need to translate > scale > translate. This works fine when I scale to the far left/right using the following type code. let x = 0; let y = this.getCanvasHeight() / 2; this.getCanvasContext().clearRect(0, 0, this.getCanvas().width, this.getCanvas().height); this.setCanvas(); ctx.translate(x, y); ctx.scale(scale, 1); ctx.translate(-x, -y); this.resetCanvasLines(); this.renderGraph(this.state.points, scale); This piece of code simply allows me to zoom into the far left of the graph. So now I'm trying to pick two points on this graph and zoom in on top of them, so that they fit evenly on the screen. The Y-Axis will always be the same. My thinking was to get the midpoint between the two points and zoom in on that location, which I feel should work but I just can't get it working. My graph width is 3010px and split into 5 segments of 602px. I want to zoom let's say from x1 = 602 and x2 = 1806, which has the midpoint of 1204. Is there a technique to properly calculating the scale amount? rangeFinder(from, to) { let points = this.state.points; if (points.length === 0) { return; } let ctx = this.getCanvasContext(); let canvasWidth = this.getCanvasWidth(); let canvasHeight = this.getCanvasHeight() / 2; let seconds = this.state.seconds; let second = canvasWidth / seconds; let scale = 1; // My graph starts from zero, goes up to 5 and the values are to represent seconds. // This gets the pixel value for the fromX value. let fromX = from * second; to = isNaN(to) ? 5 : to; // Get the pixel value for the to location. let toX = parseInt(to) * second; let y = canvasHeight / 2; // get the midpoint between the two points. let midpoint = fromX + ((toX - fromX) / 2); // This is where I really go wrong. I'm trying to calculate the scale amount let zoom = canvasWidth - (toX - fromX); let zoomPixel = (zoom / 10) / 1000; let scaleAmount = scale + ((zoom / (canvasWidth / 100)) / 100) + zoomPixel; ctx.clearRect(0, 0, this.getCanvas().width, this.getCanvas().height); this.setCanvas(); // translate and scale. ctx.translate(midpoint, y); ctx.scale(scaleAmount, 1); ctx.translate(-midpoint, -y); this.resetCanvasLines(); this.renderGraph(points); } Any help would be great, thanks.
Scale = 5/3 = total width / part width. After scale, x = 602 should have moved to 602 * 5/3 ~ 1000. Translate the new image by -1000. There is no need to find mid-point.
calculating intersection point of quadratic bezier curve
This is definitely pushing the limits for my trig knowledge. Is there a formula for calculating an intersection point between a quadratic bezier curve and a line? Example: in the image below, I have P1, P2, C (which is the control point) and X1, X2 (which for my particular calculation is just a straight line on the X axis.) What I would like to be able to know is the X,Y position of T as well as the angle of the tangent at T. at the intersection point between the red curve and the black line. After doing a little research and finding this question, I know I can use: t = 0.5; // given example value x = (1 - t) * (1 - t) * p[0].x + 2 * (1 - t) * t * p[1].x + t * t * p[2].x; y = (1 - t) * (1 - t) * p[0].y + 2 * (1 - t) * t * p[1].y + t * t * p[2].y; to calculate my X,Y position at any given point along the curve. So using that I could just loop through a bunch of points along the curve, checking to see if any are on my intersecting X axis. And from there try to calculate my tangent angle. But that really doesn't seem like the best way to do it. Any math guru's out there know what the best way is? I'm thinking that perhaps it's a bit more complicated than I want it to be.
If you only need an intersection with a straight line in the x-direction you already know the y-coordinate of the intersection. To get the x-coordinate do something like this: The equation for your line is simply y = b Setting it equal to your y-equation of the beziér function y(t) gets you: b = (1 - t) * (1 - t) * p[0].y + 2 * (1 - t) * t * p[1].y + t * t * p[2].y Solving* for t gets you: t = (p[0].y - p[1].y - sqrt(b*a + p[1].y*p[1].y - p[0].y*p[2].y)) / a with a = p[0].y - 2*p[1].y + p[2].y Insert the resulting t into your x-equation of the beziér function x(t) to get the x-coordinate and you're done. You may have to pay attention to some special cases, like when no solution exists, because the argument of the square root may then become negative or the denominator (a) might become zero, or something like that. Leave a comment if you need more help or the intersection with arbitrary lines. (*) I used wolfram alpha to solve the equation because I'm lazy: Wolfram alpha solution.
Quadratic curve formula: y=ax^2+bx+c // where a,b,c are known Line formula: // note: this `B` is not the same as the `b` in the quadratic formula ;-) y=m*x+B // where m,B are known. The curve & line intersect where both equations are true for the same [x,y]: Here's annotated code and a Demo: // canvas vars var canvas=document.getElementById("canvas"); var ctx=canvas.getContext("2d"); var cw=canvas.width; var ch=canvas.height; // linear interpolation utility var lerp=function(a,b,x){ return(a+x*(b-a)); }; // qCurve & line defs var p1={x:125,y:200}; var p2={x:250,y:225}; var p3={x:275,y:100}; var a1={x:30,y:125}; var a2={x:300,y:175}; // calc the intersections var points=calcQLintersects(p1,p2,p3,a1,a2); // plot the curve, line & solution(s) var textPoints='Intersections: '; ctx.beginPath(); ctx.moveTo(p1.x,p1.y); ctx.quadraticCurveTo(p2.x,p2.y,p3.x,p3.y); ctx.moveTo(a1.x,a1.y); ctx.lineTo(a2.x,a2.y); ctx.stroke(); ctx.beginPath(); for(var i=0;i<points.length;i++){ var p=points[i]; ctx.moveTo(p.x,p.y); ctx.arc(p.x,p.y,4,0,Math.PI*2); ctx.closePath(); textPoints+=' ['+parseInt(p.x)+','+parseInt(p.y)+']'; } ctx.font='14px verdana'; ctx.fillText(textPoints,10,20); ctx.fillStyle='red'; ctx.fill(); /////////////////////////////////////////////////// function calcQLintersects(p1, p2, p3, a1, a2) { var intersections=[]; // inverse line normal var normal={ x: a1.y-a2.y, y: a2.x-a1.x, } // Q-coefficients var c2={ x: p1.x + p2.x*-2 + p3.x, y: p1.y + p2.y*-2 + p3.y } var c1={ x: p1.x*-2 + p2.x*2, y: p1.y*-2 + p2.y*2, } var c0={ x: p1.x, y: p1.y } // Transform to line var coefficient=a1.x*a2.y-a2.x*a1.y; var a=normal.x*c2.x + normal.y*c2.y; var b=(normal.x*c1.x + normal.y*c1.y)/a; var c=(normal.x*c0.x + normal.y*c0.y + coefficient)/a; // solve the roots var roots=[]; d=b*b-4*c; if(d>0){ var e=Math.sqrt(d); roots.push((-b+Math.sqrt(d))/2); roots.push((-b-Math.sqrt(d))/2); }else if(d==0){ roots.push(-b/2); } // calc the solution points for(var i=0;i<roots.length;i++){ var minX=Math.min(a1.x,a2.x); var minY=Math.min(a1.y,a2.y); var maxX=Math.max(a1.x,a2.x); var maxY=Math.max(a1.y,a2.y); var t = roots[i]; if (t>=0 && t<=1) { // possible point -- pending bounds check var point={ x:lerp(lerp(p1.x,p2.x,t),lerp(p2.x,p3.x,t),t), y:lerp(lerp(p1.y,p2.y,t),lerp(p2.y,p3.y,t),t) } var x=point.x; var y=point.y; // bounds checks if(a1.x==a2.x && y>=minY && y<=maxY){ // vertical line intersections.push(point); }else if(a1.y==a2.y && x>=minX && x<=maxX){ // horizontal line intersections.push(point); }else if(x>=minX && y>=minY && x<=maxX && y<=maxY){ // line passed bounds check intersections.push(point); } } } return intersections; } body{ background-color: ivory; padding:10px; } #canvas{border:1px solid red;} <h4>Calculate intersections of QBez-Curve and Line</h4> <canvas id="canvas" width=350 height=350></canvas>
calculate line's tangθ with x-coordinate then intersection of the curve's (x, y) should be the same tangθ so solution is a = line's x distance from (line.x,0) to (0,0) (curve.x + a) / curve.y = tangθ (θ can get from the line intersection with x-coordidate)
Refactor word cloud algorithm
As part of a word cloud rendering algorithm (inspired by this question), I created a Javascript / Processing.js function that moves a rectangle of a word along an ever increasing spiral, until there is no collision anymore with previously placed words. It works, yet I'm uncomfortable with the code quality. So my question is: How can I restructure this code to be: readable + understandable fast (not doing useless calculations) elegant (using few lines of code) I would also appreciate any hints to best practices for programming with a lot of calculations. Rectangle moveWordRect(wordRect){ // Perform a spiral movement from center // using the archimedean spiral and polar coordinates // equation: r = a + b * phi // Calculate mid of rect var midX = wordRect.x1 + (wordRect.x2 - wordRect.x1)/2.0; var midY = wordRect.y1 + (wordRect.y2 - wordRect.y1)/2.0; // Calculate radius from center var r = sqrt(sq(midX - width/2.0) + sq(midY - height/2.0)); // Set a fixed spiral width: Distance between successive turns var b = 15; // Determine current angle on spiral var phi = r / b * 2.0 * PI; // Increase that angle and calculate new radius phi += 0.2; r = (b * phi) / (2.0 * PI); // Convert back to cartesian coordinates var newMidX = r * cos(phi); var newMidY = r * sin(phi); // Shift back respective to mid newMidX += width/2; newMidY += height/2; // Calculate movement var moveX = newMidX - midX; var moveY = newMidY - midY; // Apply movement wordRect.x1 += moveX; wordRect.x2 += moveX; wordRect.y1 += moveY; wordRect.y2 += moveY; return wordRect; }
The quality of the underlying geometric algorithm is outside my area of expertise. However, on the quality of the code, I would say you could extract a lot of functions from it. Many of the lines that you have commented could be turned into separate functions, for example: Calculate Midpoint of Rectangle Calculate Radius Determine Current Angle Convert Polar to Cartesian Coodinates You could consider using more descriptive variable names too. 'b' and 'r' require looking back up the code to see what they are for, but 'spiralWidth' and 'radius' do not.
In addition to Stephen's answer, simplify these two lines: var midX = wordRect.x1 + (wordRect.x2 - wordRect.x1)/2.0; var midY = wordRect.y1 + (wordRect.y2 - wordRect.y1)/2.0; The better statements: var midX = (wordRect.x1 + wordRect.x2)/2.0; var midY = (wordRect.y1 + wordRect.y2)/2.0;