import java.util.ArrayList;
import java.util.Random;
 
import processing.core.*;
 
public class FNakeRemake extends PApplet {
	int xSubDiv = 7; //# of subdivisions horizontally
	int ySubDiv = 10; //# of subdivisions vertically
	int offset = 15; //range for offset to vary the regular subdivisions
	float circleStroke = 2; float gridLineStroke = (float) 1.50; float lineStroke = (float) 1.3;
 
	//arrays to store randomly generated breakpoints on the x,y axis
	ArrayList xBreakPoints;
	ArrayList yBreakPoints;
	//two-dimensional array to store the y coordinates of the grid
	float[][] grid = new float[ySubDiv+1][xSubDiv+1];
 
	public void setup() {
		size(700, 700);
		frameRate((float) 0.5);
	}
 
	public void draw() {
		background(255);
		//get randomly generated breakpoints for x and y axis of canvas
		xBreakPoints = subDivide(width, xSubDiv);
		yBreakPoints = subDivide(height, ySubDiv);
 
		//compute random points for the y coordinates for the interior points
		//of the grid; the x coordinates remain the same for every column of points
		for (int j = 0; j < yBreakPoints.size(); j++) {
			int y = yBreakPoints.get(j);
			int py;
			for (int i = 0; i < xBreakPoints.size(); i++) {
				strokeWeight(gridLineStroke);
				if (i == 0) {
					grid[j][i] = y;
				} else if (i != 0 && (j == 0 || j == yBreakPoints.size()-1)) {
					grid[j][i] = y;
					line(xBreakPoints.get(i-1),y,xBreakPoints.get(i),y);
				} else {
					py = y + (int)random(-offset,offset);
					grid[j][i] = py;
					line(xBreakPoints.get(i-1),y,xBreakPoints.get(i),py);
					y = py;
				}
			}
		}
 
		for (int j = 1; j < yBreakPoints.size(); j++) {
			for (int i = 1; i < xBreakPoints.size(); i++) {
				Random randomGenerator = new Random();
				//randomly pick if the grid cell will be empty or not
				boolean isEmpty = randomGenerator.nextBoolean();
				if (!isEmpty) {
					strokeWeight(lineStroke);
					//randomly pick if the grid cell will contain straight lines or not
					boolean areStraight = randomGenerator.nextBoolean();
					if (areStraight) {
						for (float k = 0; k < 1; k += 0.03){
							boolean drawLine = randomGenerator.nextBoolean();
							if (drawLine) {
								//for the upper limit line
								float x1 = lerp((float)xBreakPoints.get(i-1), (float)xBreakPoints.get(i), k);
								float y1 = lerp((float)grid[j-1][i-1], (float)grid[j-1][i], k);
								//for the lower limit line
								float x2 = x1;
								float y2 = lerp((float)grid[j][i-1], (float)grid[j][i], k);
								line(x1,y1,x2,y2);
							}
						}
					} else {
						for (float k = 0; k 9) {
					float randX = random(xBreakPoints.get(i-1), xBreakPoints.get(i));
					float randY = random(grid[j-1][i], grid[j][i]);
					float randDiam = random(30,100);
					noFill();
					strokeWeight(circleStroke);
					ellipse(randX, randY, randDiam, randDiam);
				}
			}
		}
	}
 
	/**
	 * Randomly subdivides a distance into parts; the subdivision occurs
	 * by varying (adding or subtracting from) the regular subdivision
	 * given an allowed range equal to the 1/3 of the regular subdivision.
	 *
	 * @param size the size of the distance to be subdivided in pixels
	 * @param subDiv the number of subdivisions
	 * @return an ArrayList containing the start point, the breakpoints
	 *         and the end point of the line
	 */
	public ArrayList subDivide(int size, int subDiv) {
		//an array to store the randomly generated breakpoints
		ArrayList breakPoints = new ArrayList();
 
		int defaultSubDiv = (int) (size / (float)subDiv);
		int tempThreshold = defaultSubDiv/3;
 
		//add the start point to the array
		breakPoints.add(0);
		//get randomly generated subdivisions given the defined threshold
		for (int i = 1; i < subDiv; i++) {
			int breakPoint = breakPoints.get(i-1) + defaultSubDiv + (int)random(-tempThreshold, tempThreshold);
			breakPoints.add(breakPoint);
		}
		//add the end point to the array
		breakPoints.add(size);
		return breakPoints;
	}
}

int width = 400;
int height = 400;
void setup() {
 
  size(width, height);
  smooth();
  background(255);
  frameRate(.2);
  stroke(0);
  noFill();
  noLoop();
  strokeWeight(1.2);
}
 
void draw() {
  background(255);
   rect(0,0,width-1,height-1);
   int spacing = 20;
   int interval = 15;
   int oldx=0;
   int oldy= (int)random(spacing, spacing+5);
   int newx;
   int newy;
 
   //runs through miking wierd lines. really inefficient and dirty
   while (oldy<=height)
   {
     while( oldx < width)
     {
       newx = oldx + (int)random(spacing, spacing+20);
       newy = oldy + (int)random(-5, +5);
       line(oldx, oldy, newx, newy);
       oldx = newx;
       oldy = newy;
       int vertical = (int)random(0,3);
       if(vertical==1){
         line(oldx,oldy, oldx, oldy+(int)random(spacing+5, spacing+ 15));}
     }
     oldy = oldy+(int)random(spacing, spacing+ 5);
     oldx=0;
   }
 
   //makes circles that are always at least half showing
   for (int i=0; i< width/spacing; i++){
    ellipseMode(CENTER);
    float r = random(4,100);
    ellipse(random(0,width-r),random(0,height-r), r, r);
 
  }
 
}
void mouseClicked()
{
  redraw();
}

int[] xvalues= new int[9];
int[] xvalues= new int[9];
int[] yvalues = new int[9];
int[] yoldvalues = new int[9];
float slope1 = 0;
float slope2;
int[] yfixed= new int[8];
float xoff = 0.05;
int numCircles = 8;
Circle[] circles = new Circle[numCircles];
 
void setup() {
  size(600, 600);
 
for (int i=0; i<numCircles; i++) {
    circles[i] = new Circle(random(width),random(height)); // fill the array with circles at random positions
 
  }
 //pick first random y point
  xvalues[0] = 0; //define boundary for first point
  xvalues[1] = int(random(50, 100));
  xvalues[8]=600;// so the last line goes to the end of the box
  yfixed[0] = int(random(50, 100));
 
  //make grid of x and y points, first and last x point are set
  for (int i=2; i< 8; i++) {
    //make each new point within limits of the one before and divison
    xvalues[i] = int(random(xvalues[i-1] + 20, ((600 * i)/7)));
    //pick the next number between the a fraction of the space and the point before, but not too close
 
  }
  //first y point is constrained so that lines dont intersect
    for (int j=1; j< 8; j++) {
        yfixed[j] = int(random(yfixed[j-1] + 50, ((600 * j)/7)) );
 
         }
          for (int j=0; j< 9; j++) {
        yoldvalues[j] =0;
 
         }
 
  }
 
void draw() {
   background(255);
   //draw random circles
      for (int i=0; i<numCircles; i++) {
    circles[i].display(); // display all the circles
  }
 
//cycle through fixed y grid
for (int p=0; p < 8; p++){
        // create array of points that deviate around grid yfixed
        for(int k=0; k<9; k++){
          yvalues[k] = yfixed[p]+ int(random(-10 ,10));
       }  
 
       for (int l=0; l < 8; l++){
          line(xvalues[l], yvalues[l] , xvalues[l+1], yvalues[l+1]); //draw bands row by row
           int tofillornot= int(random(3)); // fill some parts with lines, leave others blank
 
                  if (tofillornot == 1 && l < 7) { //fill with vertical lines but not the first and last one since the slope of that is fixed
 
                        slope1 = (float((yoldvalues[l+1]- yoldvalues[l]))/ float((xvalues[l+1] - xvalues[l]))); //slope between parts of the segment
                        slope2 = (float((yvalues[l+1]- yvalues[l]))/ float((xvalues[l+1] - xvalues[l]))); //slope between parts of the segment
                        int numvertlines = int(random(20)); //some number of vertical lines
                        float ycepta= yoldvalues[l] - (slope1 * xvalues[l]);
                        float yceptb= yvalues[l+1] - (slope2 * xvalues[l+1]);
 
                      for (int m = 0; m < numvertlines; m ++){
                        //pick some x and y points and find their pairs using the slope of the bands
                             int x1 = int(random(xvalues[l], xvalues[l+1]));
 
                        float ycept1 = ycepta + (slope1 * x1); //y = mx+b
                        float ycept2 =  yceptb + (slope2 * x1);
 
                        line(x1, ycept1,x1, ycept2); //draw vertical lines
                }
 
          }
 
           if (tofillornot == 2) { //fill with diagonal lines
 
                        slope1 = (float((yoldvalues[l+1]- yoldvalues[l]))/ float((xvalues[l+1] - xvalues[l]))); //slope between parts of the segment
                        slope2 = (float((yvalues[l+1]- yvalues[l]))/ float((xvalues[l+1] - xvalues[l]))); //slope between parts of the segment
                        int numvertlines = int(random(20)); //some number of vertical lines
                        float ycepta= yoldvalues[l] - (slope1 * xvalues[l]); //y intercepts for the different slopes
                        float yceptb= yvalues[l+1] - (slope2 * xvalues[l+1]);
 
                      for (int m = 0; m < numvertlines; m ++){
                        //pick some x and y points and find their pairs using the slope of the bands
                             int x1 = int(random(xvalues[l], xvalues[l+1]));
                             int x2 = int(random(xvalues[l], xvalues[l+1]));
 
                        float ycept1 = ycepta + (slope1 * x1); //y = mx+b for top and bottom
                        float ycept2 =  yceptb + (slope2 * x2);
 
                        line(x1, ycept1,x2, ycept2); //draw diagonal line
                }
 
           }
}
 
noLoop(); //don't repeat randoms
 for (int j=0; j< 9; j++) {
        yoldvalues[j] = yvalues[j];
 
         }
} //end of p loop
}
 
//call to draw circles
class Circle {
  float x,y; // location
  float dim; // dimension
 
  Circle(float x, float y) {
    this.x = x;
    this.y = y;
    dim = random(20,90); //not too big, not too small
 
  }
 
  void display() {
    ellipse(x,y,dim,dim); // a circle at position xy
  }
}