Geometric

var LineNum = 6;

var gridPoints = [];

var lineInter =[];

var IntersectPoints = [];

var segmentedLines = [];

CanvasSize = 0;

var prev = 0;

var Pallete = ["#a8e6cf","#dcedc1","#ffd3b6","#ffaaa5",];

//var Pallete = ["#ebf4f6","#bdeaee","#76b4bd","#58668b",];

​

function setup() {

  CanvasSize = 0.95*windowHeight;

  createCanvas(CanvasSize, CanvasSize);

  background(Pallete[int(random(0,4))]);

  textAlign(CENTER);

  angleMode(DEGREES);

  lineInter.push(createVector(50,50));

  lineInter.push(createVector(50,CanvasSize-50));

  lineInter.push(createVector(CanvasSize-50,50));

  lineInter.push(createVector(CanvasSize-50,CanvasSize-50));

  Lines();

  Intersect();

  segments();

  createShapes();

}

​

function draw() {

  stroke(255);

  strokeWeight(4);

  fill(255);

  for(var y=0; y<gridPoints.length; y+=2){

    //ellipse(gridPoints[y].x, gridPoints[y].y, 20, 20);

    line(gridPoints[y].x, gridPoints[y].y, gridPoints[y+1].x, gridPoints[y+1].y);

  }

  line(lineInter[0].x, lineInter[0].y, lineInter[1].x, lineInter[1].y);

  line(lineInter[2].x, lineInter[2].y, lineInter[3].x, lineInter[3].y);

  line(lineInter[0].x, lineInter[0].y, lineInter[2].x, lineInter[2].y);

  line(lineInter[1].x, lineInter[1].y, lineInter[3].x, lineInter[3].y);

}

​

function Lines(){

  for(var x=0; x<(LineNum*2); x++){

    var locx1 = 150+random(int(CanvasSize-200));

    var locy1 = 150+random(int(CanvasSize-200));

    var choose = int(random(1,5));

    while(choose === prev){

      choose = int(random(1,5));

    }

    if(choose === 1){

      locx1 = 50;

    }else if(choose === 2){

      locx1 = CanvasSize-50;

    }else if(choose === 3){

      locy1 = 50;

    }else if(choose === 4){

      locy1 = CanvasSize-50;

    }

    gridPoints.push(createVector(locx1, locy1));

    lineInter.push(createVector(locx1, locy1));

    prev = choose;

  }

  for(c = 0; c < 2; c++){

    var calc = lineInter[c].y;

    var Valuesx = [];  // try and simplify this into a for loop( not sure how but there has to be a way

    var Valuesy = [];

    var Vpointsx = [];

    var Vpointsy = [];

    for(x = 0; x<lineInter.length; x++){

      if(lineInter[x].x === calc){

        Valuesx.push(lineInter[x].y);

        Vpointsx.push(x);

      }

      if(lineInter[x].y === calc){

        Valuesy.push(lineInter[x].x);

        Vpointsy.push(x);

      }

    }

    sorted(Valuesy, Vpointsy);

    sorted(Valuesx, Vpointsx);

  }

}

​

function Intersect(){

  for(var y=0; y<gridPoints.length; y+=2){

    for(var x=0; x<y ; x+=2){

      var x1 = gridPoints[y].x;

      var y1 = gridPoints[y].y;

      var x2 = gridPoints[y+1].x;

      var y2 = gridPoints[y+1].y;

      var x3 = gridPoints[x].x;

      var y3 = gridPoints[x].y;

      var x4 = gridPoints[x+1].x;

      var y4 = gridPoints[x+1].y;

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

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

      if(xI >= 0 && xI <= 1 && yI >= 0 && yI <= 1){

        var xInter = x1 + (xI * (x2-x1));

        var yInter = y1 + (xI * (y2-y1));

        lineInter.push(createVector(xInter,yInter));

        IntersectPoints.push(createVector(x+4, lineInter.length-1));

        IntersectPoints.push(createVector(y+4, lineInter.length-1));

      }

    }

  }

}

​

function segments(){

  for(d = 4; d < (4+LineNum*2); d= d+2){

    var Values = [];

    var VPoints = [];

    VPoints.push(d);

    VPoints.push(d+1);

    Values.push(lineInter[d].x);

    Values.push(lineInter[d+1].x);

    for(w = 0; w < IntersectPoints.length; w++){

      if(d === IntersectPoints[w].x){

        var num = IntersectPoints[w].y;

        VPoints.push(num);

        Values.push(lineInter[num].x);

      }

    }

    sorted(Values, VPoints);

  }

}

​

function createShapes(){

  for(z = 0; z < lineInter.length; z++){

    var P1 = z;

    var P2;

    var P3 = z+1;

    var P4 = z;

    var Shape = [];

    var tempval = 0;

    var result = 0;

    var count;

    if((lineInter[z].y === 50) && (lineInter[z].x != 50)){

      result = -1;

    }

    if((lineInter[z].x === CanvasSize-50) && (lineInter[z].y != CanvasSize-50)){

      result = -1;

    }

    for(y = 0; y < segmentedLines.length; y++){

      if(result != 1){

        if(z === segmentedLines[y].x || z === segmentedLines[y].y){

          if(z === segmentedLines[y].x){

            P2 = segmentedLines[y].y

          }

          if(z === segmentedLines[y].y){

            P2 = segmentedLines[y].x

          }

          result+=1;

        }

      }

    }

    Shape.push(P1);

    Shape.push(P2);

    //while(P3 != P1){

    while(Shape[0] != Shape[Shape.length-1]){

      var Anglecheck = 361;

      for(b = 0; b < segmentedLines.length; b++){

        if((P2 === segmentedLines[b].x || P2 === segmentedLines[b].y) && (P1 != segmentedLines[b].x && P1 != segmentedLines[b].y)){

          if(P2 === segmentedLines[b].x){

            tempval = segmentedLines[b].y

          }

          if(P2 === segmentedLines[b].y){

            tempval = segmentedLines[b].x

          }

          let V1 = createVector(lineInter[P1].x - lineInter[P2].x,lineInter[P1].y - lineInter[P2].y);

          let V2 = createVector(lineInter[tempval].x - lineInter[P2].x, lineInter[tempval].y - lineInter[P2].y);

          let Angle3 = V2.angleBetween(V1);

          if(Angle3 <= 0){

            Angle3 = 360 + Angle3;

          }

          if(Angle3 < Anglecheck){

              Anglecheck = Angle3;

              P3 = tempval;

          }

        }

      }

      Shape.push(P3);

      P1 = P2;

      P2 = P3;

    }

    var filler = int(random(0,4));

    fill(Pallete[filler]);

    beginShape();

    for(p = 0; p < Shape.length; p++){

      vertex(lineInter[Shape[p]].x,lineInter[Shape[p]].y);

    }

    endShape(CLOSE);

  }

  noStroke(0);

  fill(0);

  textSize(15);

  text("Press Enter to create a new Design", CanvasSize/2, CanvasSize-25);

}

​

function sorted(Array, Array2){

  var List = Array;

  var Num = Array2;

  for(s = 0; s < List.length; s++){

      for(t = 0; t < s; t++){

        if(List[t] > List[s]){

          var temp3 = List[s];

          var temp4 = Num[s];

          List[s] = List[t];

          List[t] = temp3;

          Num[s] = Num[t];

          Num[t] = temp4;

        }

      }

    }

    for(a = 0; a < Num.length-1; a++){

      segmentedLines.push(createVector(Num[a], Num[a+1]));

    }

}

​

function keyPressed(){

  if(keyCode === ENTER){

    gridPoints = [];

    lineInter =[];

    IntersectPoints = [];

    segmentedLines = [];

    background(Pallete[int(random(0,4))]);

    lineInter.push(createVector(50,50));

    lineInter.push(createVector(50,CanvasSize-50));

    lineInter.push(createVector(CanvasSize-50,50));

    lineInter.push(createVector(CanvasSize-50,CanvasSize-50));

    Lines();

    Intersect();

    segments();

    createShapes();

  }

}