river cut - OpenProcessing

mySketch
xxxxxxxxxx
 
//For the #wccChallenge on the theme of 'Ku Shulan'
//I didn't want try to copy Ku Shulan's art, but did use some of the patterns in some of her work
//The image is a collage of sorts, with patterns being drawn to 'papers' of graphic buffers, which
//are then 'cut' by erasing shapes. It ended up fairly folk-arty, which seems appropriate.
//Code is a mess, there's probably a ton in here I'm not even using anymore.
​
let colors=["#f6ac2c","#b7656b","#05729b","#5e899e","#601d24","#8ea400","#03417b"]
let paper1
let simplex
​
function setup() {
  let m=min(windowWidth, windowHeight)
  createCanvas(m, m);
  background(255);
  
  simplex= new openSimplexNoise(Date.now())
  shuffle(colors, true)
  //paper1= createGraphics(300, 300)
  let river= createGraphics(width, height*0.7)
  let bigtree= createGraphics(width*0.15,height*0.5)
  let littletree= createGraphics(width*0.1, height*0.4)
  diamondPattern(height*0.033, bigtree)
  diamondPattern(height*0.033, littletree)
  
  treeCut(width*0.15,height*0.5, bigtree, 1)
  treeCut(width*0.15,height*0.5, littletree, 2)
  zigzagPattern(river.width/25, river)
  riverCut(width, height*0.66, river)
  
  noStroke()
  fill(colors[5])
  rect(0, 0, width, height/3)
  
  fill(colors[3])
  rect(0, height/3, width, height)
  for(let y=height*0.33; y<=height; y+=10){
    push()
    stroke(colors[6])
    sw=map(y, height*0.33, height, 0.1, 2)
    strokeWeight(sw)
    line(0, y, width, y)
    
    pop()
  }
  
  for(let y=0; y<height*0.33; y+=10){
    for(let x=0; x<width; x+=10){
    let r= random(3,5)
    //let x= x
    fill(colors[6])
    star(x+random(-1, 1), y+random(-1, 1), r)
  }
  }
  for(let x=random(width*0.1); x<width*0.8; x+=random(width*0.2, width*0.3)){
    let bump= random(height*0.05)
//    let newH= littletree.height*scaler
  //  let newW= littletree.width*scaler
    image(littletree, x,  -bump)
  }
  image(bigtree, height*0.265, 0)
  image(river, 0, height*0.33)
  
}
​
​
​
function treeCut(h, w, canvas, seed){
  canvas.fill(0)
  canvas.erase()
  canvas.beginShape()
  canvas.vertex(0, 0)
  for(let y=0; y<canvas.height; y++){
    let cutIn=canvas.width*0.1
    if(y>canvas.height*0.8){
      cutIn= map(y, canvas.height*0.8, canvas.height, canvas.width*0.1, 0)
    }
    let waver= simplex.noise2D(y/10, seed)*(cutIn*0.1)
    canvas.vertex(cutIn+waver, y) 
  }
  canvas.vertex(0, height)
  canvas.vertex(0, 0)
  canvas.endShape()
  canvas.fill(0)
  canvas.beginShape()
  canvas.vertex(width, 0)
  for(let y=0; y<canvas.height; y++){
    let cutIn=canvas.width*0.1
    if(y>canvas.height*0.8){
      cutIn= map(y, canvas.height*0.8, canvas.height, canvas.width*0.1, 0)
    }
    let waver= simplex.noise2D(y/10, seed)*(cutIn*0.1)
    canvas.vertex(canvas.width-cutIn-waver, y)  
  }
  canvas.vertex(width, height)
  canvas.vertex(width, 0)
  canvas.endShape()
  canvas.noErase()
  
}
​
​
function zigzagPattern(patternHeight, canvas){
  canvas.background(colors[0])
  canvas.noStroke()
  canvas.fill(colors[1])
  let hStep= patternHeight*0.5
  for(let y=0; y<canvas.height+patternHeight; y+=patternHeight){
    canvas.beginShape()
    for(let x=0; x<canvas.width+patternHeight; x+=patternHeight){
      vertex(x, y-hStep)
      vertex(x+hStep, y)
      vertex(x+patternHeight, y-hStep)
    }
    
    for(let x=canvas.width+patternHeight*0.5; x>=0; x-=patternHeight){
      vertex(x+hStep, y)
      vertex(x, y+hStep)
      vertex(x-hStep, y)
    }
    canvas.endShape()
  } 
  canvas.fill(colors[2])
  for(let y=0; y<canvas.height+patternHeight; y+=patternHeight){
  for(let x=0; x<canvas.width+patternHeight; x+=patternHeight){
    canvas.ellipse(x, y-patternHeight*0.7125, patternHeight*0.25)
    canvas.ellipse(x+hStep, y+patternHeight*0.7125, patternHeight*0.25)
  }
  }
  
}
​
function riverCut(patternWidth, patternHeight, canvas){
  canvas.fill(0)
  canvas.erase()
  canvas.beginShape()
  canvas.vertex(0, 0)
  canvas.vertex(canvas.width, 0)
  let beg= createVector(canvas.width, 0)
  let end= createVector(-canvas.height*0.2, canvas.height)
  for(i=0; i<canvas.width; i+=0.001){
    let basePos=p5.Vector.lerp(beg, end, i)
    let xoff= simplex.noise2D(i*2, 1)*(canvas.width*0.1)+ simplex.noise2D(i*20, 1)*canvas.width*0.005
    let yoff= simplex.noise2D(i*2, 2)*(canvas.width*0.1)+ simplex.noise2D(i*20, 2)*canvas.width*0.005
    canvas.vertex(basePos.x+xoff, basePos.y+yoff)
  }
  canvas.endShape()
  
  canvas.beginShape()
  let rbeg= createVector(canvas.width*1.1, canvas.height*0.2)
  let rend= createVector(canvas.height*0.6, canvas.height)
  for(i=0; i<canvas.width; i+=0.001){
    let basePos=p5.Vector.lerp(rbeg, rend, i)
    let xoff= simplex.noise2D(i*2, 1.1)*(canvas.width*0.1)+ simplex.noise2D(i*20, 1)*canvas.width*0.005
    let yoff= simplex.noise2D(i*2, 2.1)*(canvas.width*0.1)+simplex.noise2D(i*20, 2)*canvas.width*0.005
    canvas.vertex(basePos.x+xoff, basePos.y+yoff)
  }
  let xendOff= simplex.noise2D(0, 1.1)*(canvas.width*0.1)
  let yendOff= simplex.noise2D(0, 2.1)*(canvas.width*0.1)
  let xbegOff= simplex.noise2D(2, 1.1)*(canvas.width*0.1)
  let ybegOff=simplex.noise2D(2, 2.1)*(canvas.width*0.1)
  canvas.vertex(width+width*0.5, height)
  canvas.vertex(rbeg.x+xbegOff, rbeg.y+ybegOff)
  
//  canvas.vertex(rend.x+xendOff, rend.y+yendOff)
  
  
  
  canvas.endShape(CLOSE)
  
  canvas.noErase()
}
​
function diamondPattern(patternHeight, canvas){
  canvas.background(colors[3])
  //canvas.noStroke()
  canvas.stroke(colors[4])
  canvas.noFill()
  canvas.strokeWeight(patternHeight*0.05)
  let hStep= patternHeight*0.5
  let pwh= hStep*0.35
  for(let y=0; y<canvas.height+patternHeight; y+=patternHeight*0.9){
    for(let x=0; x<canvas.width+patternHeight; x+=hStep){
      canvas.line(x, y, x+pwh, y-pwh)
      canvas.line(x, y,  x-pwh, y-pwh)
      canvas.line(x, y+patternHeight*0.125, x+pwh, y-patternHeight*0.05)
      canvas.line(x, y+patternHeight*0.125, x-pwh, y-patternHeight*0.05)
      canvas.line(x, y+patternHeight*0.125, x+pwh, y+patternHeight*0.25)
      canvas.line(x, y+patternHeight*0.125, x-pwh, y+patternHeight*0.25)
      canvas.line(x, y+patternHeight*0.25, x+pwh, y+patternHeight*0.4)
      canvas.line(x, y+patternHeight*0.25, x-pwh, y+patternHeight*0.4)
      canvas.line(x, y+patternHeight*0.375, x+pwh, y+patternHeight*0.525)
      canvas.line(x, y+patternHeight*0.375, x-pwh, y+patternHeight*0.525)
      canvas.line(x, y+patternHeight*0.5, x+pwh, y+patternHeight*0.65)
      canvas.line(x, y+patternHeight*0.5, x-pwh, y+patternHeight*0.65)
    }
  }
​
  
  
  
}
​
​
function uShapeCut(r, canvas){
  canvas.erase()
  canvas.beginShape()
  canvas.vertex(0, 0)
  canvas.vertex(paper1.width, 0)
  canvas.vertex(paper1.width, paper1.height)
  canvas.vertex(0, paper1.height)
  canvas.beginContour()
  for(let a=0; a<=PI; a+=PI/100){
    let x= paper1.width*0.5+cos(a)*r
    let y=paper1.height*0.5+sin(a)*r
    canvas.vertex(x, y)
  }
  for(let a=PI; a>0; a-=PI/100){
    let x= paper1.width*0.5+cos(a)*r
    let y=paper1.height*0.5+sin(a)*r
    canvas.vertex(x, y)
  }
  
  
  canvas.endContour()
  canvas.endShape(CLOSE)
  paper1.noErase()
}
​
function star(x, y, r){
  noStroke()
  fill(colors[6])
  push()
  translate(x, y)
  rotate(random(TAU))
  beginShape()
  for(let a=TAU; a>=0; a-=TAU/11){
    vertex(cos(a)*r, sin(a)*r)
    vertex(cos(a-TAU/30)*(r*0.5), sin(a-TAU/30)*(r*0.5))
  }
  endShape(CLOSE)
  pop()
}
​
function starShapeCut(r, canvas){
  canvas.erase()
  canvas.fill(0)
  canvas.beginShape()
  canvas.vertex(0, 0)
  canvas.vertex(paper1.width, 0)
  canvas.vertex(paper1.width, paper1.height)
  canvas.vertex(0, paper1.height)
  canvas.beginContour()
  
  for(let a=TAU; a>=0; a-=TAU/15){
    canvas.vertex(canvas.width*0.5+ cos(a)*r, canvas.height*0.5+sin(a)*r)
    canvas.vertex(canvas.width*0.5+ cos(a-TAU/30)*(r*0.75), canvas.height*0.5+sin(a-TAU/30)*(r*0.75))
  }
  canvas.endContour()
  canvas.endShape()
  canvas.noErase()
  
}