## Sepho-Intersections

```//// Based on the Starter Code for "Embedded Iteration + Randomness" var boolDoRefresh;   var lines = []; var lineNumber = 12; //&lt;&lt;-----change this number to add/remove lines!   function setup() { createCanvas(720, 480); background(20,20,50) noStroke(); boolDoRefresh = true; }   // Math for the intersection of two lines from Paul Bourke http://paulbourke.net/geometry/pointlineplane/ //takes two lines and returns the x,y value for the inersection of those lines function intersec(a,b){ var x1 = a[0]; var y1 = a[1]; var x2 = a[2]; var y2 = a[3];   var x3 = b[0]; var y3 = b[1]; var x4 = b[2]; var y4 = b[3];   var ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / ((y4-y3) * (x2-x1) - (x4-x3) * (y2-y1)); var ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / ((y4-y3) * (x2-x1) - (x4-x3) * (y2-y1)); var x = (x1 + ua * (x2 - x1)); var y = (y1 + ua * (y2 - y1));   if (ua &lt; 0 || ua &gt; 1 || ub &lt; 0 || ub &gt; 1) { return [-20,-20]; }   return[x,y]; }   //moves the lines according to each points velocity. function updateLines(lines){ for(var i = 0; i &lt; lines.length; i++){ var l = lines[i]; l[0] += l[4]; l[1] += l[5]; l[2] += l[6]; l[3] += l[7]; } }     function draw() { updateLines(lines);   //Draws all of the lines: background(20,20,50) stroke(255, 50); fill(255); for(var i = 0; i &lt; lines.length; i++){ line(lines[i][0],lines[i][1],lines[i][2],lines[i][3]); }   //Draws a red dot at all of the intersections: for(var i = 0; i &lt; lines.length; i++){ for(var j = 0; j &lt; lines.length; j++){ if(i != j){ la = lines[i]; lb = lines[j]; noStroke() fill(255,0,0); ellipse(intersec(la,lb)[0],intersec(la,lb)[1],3); } } }   if (boolDoRefresh) { boolDoRefresh = false; //Creates new lines: lines = []; for(var i = 0; i &lt; lineNumber; i++){ lines.push([random(width),random(height),random(width),random(height),random(-1,1), random(-1,1),random(-1,1),random(-1,1)]) } } }   function mousePressed() { boolDoRefresh = true; }```

## airsun-Intersections

```//Clair(sijing) Sun
//sijings@andrew.cmu.edu
//Assignment-5

var lineP=[];
var boolDoRefresh;
var numberofL=10;

function setup() {
createCanvas(480, 480);
boolDoRefresh = false;
for (var i=0; i<numberofL; i++){
var x1 = random(0,width);
var x2 = random(0,width);
var y1 = random(0,height);
var y2 = random(9,height);
lineP[i] = [x1,y1,x2,y2];
}
}

function draw() {
background(200);

//regenerate if mousePressed
if (boolDoRefresh) {
for (var i=0; i<numberofL; i++){
var x1 = random(0,width);
var x2 = random(0,width);
var y1 = random(0,height);
var y2 = random(9,height);
lineP[i] = [x1,y1,x2,y2];
}
boolDoRefresh=false
}

//for drawing the lines
for (var i = 0; i < numberofL; i += 1){
line(lineP[i][0],lineP[i][1],lineP[i][2],lineP[i][3]);
}

//for drawing the intersections, spliting to two lines each time
for (var j = 0; j < numberofL; j += 1){
for (var i = 0; i < numberofL; i += 1){
var x1 = lineP[j][0];
var y1 = lineP[j][1];
var x2 = lineP[j][2];
var y2 = lineP[j][3];
var x3 = lineP[i][0];
var y3 = lineP[i][1];
var x4 = lineP[i][2];
var y4 = lineP[i][3];
intersect(x1, y1, x2, y2, x3, y3, x4, y4);
}
}

}

// Modified from line intercept math by Paul Bourke http://paulbourke.net/geometry/pointlineplane/
// Determine the intersection point of two line segments
// Modified from http://paulbourke.net/geometry/pointlineplane/javascript.txt
function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {
if ((x1 == x2 && y1 == y2) || (x3 == x4 && y3 == y4)) {
return false
}

var denom = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1))

if (denom === 0) {
return false
}

var ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denom
var ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denom

// is the intersection along the segments
if (ua < 0 || ua > 1 || ub < 0 || ub > 1) {
return false
}

fill(0);
ellipse (x1 + ua * (x2 - x1),y1 + ua * (y2 - y1),15);
}

function mousePressed() {
boolDoRefresh = true;
}
```

## chaine-Intersections

``` var boolDoRefresh; var size = 40; var lineLength = 300; var numLines = 12; var lineList = []; var x = []; //var circleCoords = []; //var circleList = []; //var foo = 0;   function setup(){ createCanvas(728, 480); background(255,255,255); boolDoRefresh = true; for (var i = 0; i &lt; numLines; i ++){ append(x, int(random(150, width - 150))); //starting x append(x, int(random(150, height - 150))); //starting y append(x, int(random(0, 361))); //angle of line append(lineList, x); x = []; } }   function draw(){ if (boolDoRefresh == true){ for (var j = 0; j &lt; lineList.length; j++){ //drawing where the circles should be var a1 = lineList[j][0]; var b1 = lineList[j][1]; var angle2 = lineList[j][2]; var a2 = a1+lineLength*cos(angle2); var b2 = b1+lineLength*sin(angle2); for (var k = 0; k &lt;lineList.length; k++){ var a3 = lineList[k][0]; var b3 = lineList[k][1]; var angle3 = lineList[k][2]; var a4 = a3+lineLength*cos(angle3); var b4 = b3+lineLength*sin(angle3); //This long formula was taken from http://www-cs.ccny.cuny.edu/~wolberg/capstone/intersection/Intersection%20point%20of%20two%20lines.html //Paul Bourke's paper if (((b4-b3)*(a2-a1)-(a4-a3)*(b2-b1))!=0){ var ta = ((a4-a3)*(b1-b3)-(b4-b3)*(a1-a3))/((b4-b3)*(a2-a1)-(a4-a3)*(b2-b1)); var tb = ((a2-a1)*(b1-b3)-(b2-b1)*(a1-a3))/((b4-b3)*(a2-a1)-(a4-a3)*(b2-b1)); } else { ta = -1; tb = -1; } if (ta &gt;= 0 &amp;&amp; ta &lt;= 1 &amp;&amp; tb &gt;= 0 &amp;&amp; tb &lt;= 1){ fill(204,229, 255); strokeWeight(0); ellipse((a1+ta*(a2-a1)),(b1+ta*(b2-b1)), 20); } else{ continue; } }   fill(255,255,255); strokeWeight(0.1); for (var i = 0; i &lt; numLines; i++){ var x1 = lineList[i][0]; var y1 = lineList[i][1]; var angle = lineList[i][2]; //below formula from https://stackoverflow.com/questions/48525583/get-a-points-position-from-an-angle-and-the-length-of-the-line line(x1, y1, x1+lineLength*cos(angle), y1+lineLength*sin(angle)); //append(lineList[i], x1+lineLength*cos(angle)); //append(lineList[i], y1+lineLength*sin(angle)); } //print(a2,b2); //print(lineList); //print(ta, tb); } } boolDoRefresh = false; }   function mousePressed(){ boolDoRefresh = true; x = []; lineList = []; setup(); }```

## Spoon-Intersections

Intersections with 12 lines.

Intersections with 100 lines

```1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 var boolDoRefresh; const NUM_LINES = 12;   function setup() { createCanvas(720, 480); background('#FFFFFF'); strokeWeight(5); boolDoRefresh = true; }   function draw() { if(boolDoRefresh) { background('#FFFFFF'); var lines = constructLines(); findIntersections(lines); boolDoRefresh = false; } }   function mousePressed() { boolDoRefresh = true; }   function constructLines() { const LINE_LENGTH = 250; var lines = []; for(var i = 0; i < NUM_LINES; i++) { var x1 = random(720); var y1 = random(480); var x2 = random(100) > 50 ? x1 - random(LINE_LENGTH) : x1 + random(LINE_LENGTH); var y2 = ((random(100) > 50 ? 1 : -1) * sqrt(sq(LINE_LENGTH) - sq(x1 - x2))) + y1;   line(x1, y1, x2, y2); lines[i] = [x1, y1, x2, y2]; } return lines; }   function findIntersections(lines) { //uses calculations found at http://paulbourke.net/geometry/pointlineplane/ //draws circles around any points where lines intersect for(var i = 0; i < NUM_LINES; i++) { for(var j = i + 1; j < NUM_LINES; j++) { var x1 = lines[i][0]; var x2 = lines[i][2]; var y1 = lines[i][1]; var y2 = lines[i][3];   var x3 = lines[j][0]; var x4 = lines[j][2]; var y3 = lines[j][1]; var y4 = lines[j][3];   var u1 = (((x4 - x3) * (y1 - y3)) - ((y4 - y3) * (x1 - x3))) / (((y4 - y3) * (x2 - x1)) - ((x4 - x3) * (y2 - y1))); var u2 = (((x2 - x1) * (y1 - y3)) - ((y2 - y1) * (x1 - x3))) / (((y4 - y3) * (x2 - x1)) - ((x4 - x3) * (y2 - y1)));   if(u1 > 0 && u1 < 1 && u2 > 0 && u2 < 1) { var x = x1 + (u1 * (x2 - x1)); var y = y1 + (u1 * (y2 - y1)); fill('#FFC600'); ellipse(x, y, 15); } } } }```

## nerual-Intersections

```var boolDoRefresh;
var lineArr;
var bkgrd = 255;
var canvasW = 600;
var canvasH = 600;
var numLines = 12;

function setup() {
createCanvas(canvasW, canvasH);
boolDoRefresh = true;
background(bkgrd);
lineArr = [];
//noFill();
}

function draw() {
var x1,x2,x3,x4,y1,y2,y3,y4;
if (boolDoRefresh) {
for (var i = 0; i < numLines; i++) {
createLine();
}

for (i = 0; i+1 < numLines; i++){
for (j = i+1; j < numLines; j++){
var a = lineArr[i];
var b = lineArr[j];
drawIntersect(a,b);
}
}

boolDoRefresh = false;
}
}

function createLine() {
x1 = random(canvasW);
y1 = random(canvasH);
x2 = random(canvasW);
y2 = random(canvasH);
stroke(0);
line(x1,y1,x2,y2);
lineArr.push([x1,y1,x2,y2]);
}

function drawIntersect(a, b){
x1 = a[0]; y1 = a[1]; x2 = a[2]; y2 = a[3];
x3 = b[0]; y3 = b[1]; x4 = b[2]; y4 = b[3];

var denom = (y4-y3)*(x2-x1) - (x4-x3)*(y2-y1);
if (denom == 0) {
return;
}

var ua = ((x4-x3)*(y1-y3) - (y4-y3)*(x1-x3))/denom;
var ub = ((x2-x1)*(y1-y3) - (y2-y1)*(x1-x3))/denom;

var ix = x1 + ua*(x2-x1);
var iy = y1 + ua*(y2-y1);

if (ua < 0 || ua > 1 || ub < 0 || ub > 1) {
return;
}
noStroke();
fill(random(256),random(256),random(256),150);
ellipse(ix, iy, 20, 20);
fill(255,255,255,200);
ellipse(ix,iy,5,5);
resetProps();
}

function resetProps(){
stroke(0);
}

function mousePressed() {
lineArr = [];
background(bkgrd);
boolDoRefresh = true;
}
```

## sapeck-Intersections

```/* Sapeck 9/6/2017 "sapeck-Intersections" 60-212 Carnegie Mellon University Copyright (C) 2018-present Sapeck This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License version 3 as published by the Free Software Foundation. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. */   var NUM_LINES = 12   function setup() { createCanvas(720, 480) boolDoRefresh = true }   function draw() { if (boolDoRefresh) { background(255);   let lines = [] let intersects = [] for (let i=0;i&lt;NUM_LINES;i++) { let thisLine = { x1: floor(random(0, width)), y1: floor(random(0, height)), y2: floor(random(0, height)) } thisLine.x2 = floor(random(thisLine.x1+1, width)) thisLine.m = (thisLine.y2 - thisLine.y1) / (thisLine.x2 - thisLine.x1) lines.push(thisLine) } for (let i=0;i&lt;lines.length;i++) { for (let j=i+1;j&lt;lines.length;j++) { if (i !== j) { let thisLine = lines[i] let testLine = lines[j]   // My brute-force-test-x method that didn't entirely work // for (let thisX=thisLine.x1;thisX&lt;=thisLine.x2;thisX+=0.1) { // let thisY = floor((thisLine.m * (thisX-thisLine.x1)) + thisLine.y1) // let testY = floor((testLine.m * (thisX-testLine.x1)) + testLine.y1) // if (thisY==testY) intersects.push({x: thisX, y: thisY}) // }   // Paul Bourke's method (see function defintion below for full citation) let x1 = thisLine.x1, x2 = thisLine.x2, x3 = testLine.x1, x4 = testLine.x2 let y1 = thisLine.y1, y2 = thisLine.y2, y3 = testLine.y1, y4 = testLine.y2 let intersection = intersect(x1, y1, x2, y2, x3, y3, x4, y4) if (intersection !== false) intersects.push({x: intersection.x, y: intersection.y}) } } } for (let i=0;i&lt;lines.length;i++) { let thisLine = lines[i] stroke(color(0,0,255)) line(thisLine.x1, thisLine.y1, thisLine.x2, thisLine.y2) } for (let i=0;i&lt;intersects.length;i++) { let intersection = intersects[i] noStroke(); fill(color(255,0,0,50)) ellipse(intersection.x,intersection.y,20,20) }   boolDoRefresh = false } }   function mousePressed() { boolDoRefresh = true }   // line intercept math by Paul Bourke http://paulbourke.net/geometry/pointlineplane/ // Determine the intersection point of two line segments // Return FALSE if the lines don't intersect function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {   // Check if none of the lines are of length 0 if ((x1 === x2 &amp;&amp; y1 === y2) || (x3 === x4 &amp;&amp; y3 === y4)) { return false }   denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1))   // Lines are parallel if (denominator === 0) { return false }   let ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator let ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denominator   // is the intersection along the segments if (ua &lt; 0 || ua &gt; 1 || ub &lt; 0 || ub &gt; 1) { return false }   // Return a object with the x and y coordinates of the intersection let x = x1 + ua * (x2 - x1) let y = y1 + ua * (y2 - y1)   return {x, y} }```

## nannon-Intersections

```  var boolDoRefresh; var linelist=[] var numSlider   function setup() { createCanvas(720,480); boolDoRefresh = true; }   function rando(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; //The maximum is inclusive and the minimum is inclusive }   // function findintersection(line1, line2) { // return math.intersect(line1[0], line1[1], line2[0], line2[1]) // }   function intersect(x1, y1, x2, y2, x3, y3, x4, y4) { if ((x1 === x2 &amp;&amp; y1 === y2) || (x3 === x4 &amp;&amp; y3 === y4)) { return false } denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)) if (denominator === 0) { return false } let ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator let ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denominator if (ua &lt; 0 || ua &gt; 1 || ub &lt; 0 || ub &gt; 1) { return false } let x = x1 + ua * (x2 - x1) let y = y1 + ua * (y2 - y1)   return [x, y] }   function draw() { if (boolDoRefresh) { var numLines= 15 background("#FFE6E6"); linelist=[] for (i=0;i&lt;numLines;i++){ var startx= rando(0, width) var starty= rando(0, height) var endx = rando(0, width) var endy = rando(0, height) stroke("#FF0000"); strokeWeight(2); line(startx, starty, endx,endy) linelist.push([[startx,starty],[endx,endy]]) if (linelist.length &gt;1) { for (j=0;j&lt;i; j++) { var inter = intersect(linelist[i][0][0], linelist[i][0][1], linelist[i][1][0], linelist[i][1][1], linelist[j][0][0], linelist[j][0][1], linelist[j][1][0], linelist[j][1][1],) if (inter) { strokeWeight(2) fill('rgba(255,0,0, 0.25)') ellipse(inter[0], inter[1], 20,20) } } } } boolDoRefresh = false; } }   function mousePressed() { boolDoRefresh = true; }   //random function from: //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random   //intersect function from: //http://paulbourke.net/geometry/pointlineplane/javascript.txt```

## yuvian-Intersections

intersections

twelve intersections

seventy intersections

```
var lines = [];
var numOfLines = 12;
var intersectXArray =[];
var intersectYArray = [];

var yAxis = 1;
var c1, c2, c3;

function setup() {
createCanvas(720, 480);

background(0);

c1 = color(0);
c2 = color(16, 45, 117);
c3 = color(244, 89, 66);

setGradient(0, 0, windowWidth, windowHeight / 2, c1, c2, yAxis);

setGradient(0, windowHeight/2, windowWidth, windowHeight, c2, c3, yAxis);

for (var i = 0; i < numOfLines; i++) {
lines.push(new Line());
}

}

function draw() {
for (var i = 0; i < lines.length; i++) {
lines[i].display();
}

for (var i = 0; i < lines.length; i++) {
for (var j = 0; j < lines.length; j++) {
intersectXArray.push(intersect(lines[i].x1, lines[i].y1, lines[i].x2, lines[i].y2, lines[j].x1, lines[j].y1, lines[j].x2, lines[j].y2).x);
intersectYArray.push(intersect(lines[i].x1, lines[i].y1, lines[i].x2, lines[i].y2, lines[j].x1, lines[j].y1, lines[j].x2, lines[j].y2).y);
}
}

// display twinkling stars as intersection points
for (var i = 0; i < intersectXArray.length; i++) {
star = new Star(intersectXArray[i], intersectYArray[i]);
star.display();
star.twinkle();
}
}

function mousePressed() {
lines = [];
intersectXArray = [];
intersectYArray = [];
setup();
}

function Line() {
this.x1 = random(0, width);
this.y1 = random(0, height);
this.x2 = random(0, width);
this.y2 = random(0, height);

this.display = function() {
stroke(249, 252, 232, 20);
strokeWeight(1);
line(this.x1, this.y1, this.x2, this.y2);
}
}

function Star(x,y) {
this.x = x;
this.y = y
this.r = random(8);

this.display = function() {
stroke(22, 71, 119);
fill(255);
this.rc = constrain(this.r, 0, 9);
ellipse(this.x, this.y, this.rc, this.rc);
};

this.twinkle = function() {
if (this.r < 3) {
this.r += random(-.5,1.5);
} else if (this.r >= 3 && this.r < 6) {
this.r += random(-1,1);
} else if (this.r >=6 && this.r <=9) {
this.r += random(-1.5,0.5);
}

}
}

function setGradient(x, y, w, h, c1, c2, axis) {
noFill();
if (axis == yAxis) {  // Top to bottom gradient
for (var i = y; i <= y+h; i++) {
var inter = map(i, y, y+h, 0, 1);
var c = lerpColor(c1, c2, inter);
stroke(c);
line(x, i, x+w, i);
}
}
}

//from Paul Bourke http://paulbourke.net/geometry/pointlineplane/javascript.txt
function intersect(x1, y1, x2, y2, x3, y3, x4, y4) {

// Check if none of the lines are of length 0
if ((x1 === x2 && y1 === y2) || (x3 === x4 && y3 === y4)) {
return false
}

denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1))

// Lines are parallel
if (denominator === 0) {
return false;
}

let ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator;
let ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denominator;

// is the intersection along the segments
if (ua < 0 || ua > 1 || ub < 0 || ub > 1) {
return false
}

// Return a object with the x and y coordinates of the intersection
let x = x1 + ua * (x2 - x1)
let y = y1 + ua * (y2 - y1)

return {x, y}
}

```

## casher-intersections

```var boolDoRefresh = true; var lines = [];   function setup() { createCanvas(720, 480); }   function draw() { if (boolDoRefresh) {   // set design values background(201, 239, 255); strokeWeight(1.5); stroke(140, 81, 200); lines = [];   // assign random values to points of each line for (var k = 0; k &lt; 12; k++) { x1 = random(720); y1 = random(480); x2 = random(720); y2 = random(480); var newLine = [x1, y1, x2, y2]; lines.push(newLine); }   // double loop takes points from line[] to make a line // and forms an ellipse at the points from findIntersection() for (var i = 0; i &lt; 12; i++) { for (var j = 0; j &lt; 12; j++) { line(lines[i][0], lines[i][1], lines[i][2], lines[i][3]) var steve = findIntersection(lines[i][0], lines[i][1], lines[i][2], lines[i][3], lines[j][0], lines[j][1], lines[j][2], lines[j][3])   ellipse(steve[0],steve[1],20,20) } } } boolDoRefresh = false; }   //adapted from Paul Bourkes/Leo Bottaro http://paulbourke.net/geometry/pointlineplane/javascript.txt function findIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {   // Check if none of the lines are of length 0 if ((x1 === x2 &amp;&amp; y1 === y2) || (x3 === x4 &amp;&amp; y3 === y4)) { return false }   denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1))   // Lines are parallel if (denominator === 0) { return false }   let ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator let ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denominator   // is the intersection along the segments if (ua &lt; 0 || ua &gt; 1 || ub &lt; 0 || ub &gt; 1) { return false }   // Return a object with the x and y coordinates of the intersection let x = x1 + ua * (x2 - x1) let y = y1 + ua * (y2 - y1)   return[x, y] }   function mousePressed() { boolDoRefresh = true; }```

## breep-Intersections

```// Generating random lines and highlighting intersections var boolDoRefresh; var slider; var totalLines;     function setup() { createCanvas(720, 480); background(255, 117, 102); boolDoRefresh = true; slider = createSlider(1, 100, 12) slider.position(10, 10) }   function draw() {     if (boolDoRefresh) { lines = []; background(255, 179, 102);   for ( i = 0; i < slider.value(); i ++){ var x1 = random(width); var x2 = random(width); var y1 = random(height); var y2 = random(height); lines[i] = [x1, y1, x2, y2] }   // Line intersections for ( i = 0; i < slider.value(); i++){ for ( j = 0; j < slider.value(); j++){     var intersection = findingIntersection(lines[i][0], lines[i][1], lines[i][2], lines[i][3], lines[j][0], lines[j][1], lines[j][2], lines[j][3]); if ( intersection != false) { stroke(0); fill(173, 216, 230); ellipse(intersection.x, intersection.y, 20, 20); } } }     // Line drawing for (i = 0; i < slider.value(); i ++){ strokeWeight(1); line( lines[i][0], lines[i][1], lines[i][2], lines[i][3]) } fill(0); text(slider.value(), 150, 27) boolDoRefresh = false; } }   function mousePressed() { boolDoRefresh = true }   // Function implementation inspired by Paul Bourke's algorithm // http://paulbourke.net/geometry/pointlineplane/function // And implemented by Leo Bottaro // http://paulbourke.net/geometry/pointlineplane/javascript.txt   function findingIntersection(x1, y1, x2, y2, x3, y3, x4, y4) {   // Check if none of the lines are of length 0 if ((x1 === x2 && y1 === y2) || (x3 === x4 && y3 === y4)) { return false }   denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1))   // Lines are parallel if (denominator === 0) { return false }   let ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)) / denominator let ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)) / denominator   // is the intersection along the segments if (ua < 0 || ua > 1 || ub < 0 || ub > 1) { return false }   // Return a object with the x and y coordinates of the intersection let x = x1 + ua * (x2 - x1) let y = y1 + ua * (y2 - y1)   return {x, y} }```