Popcorn over vector fields

popcorn_vf.pde

ArrayList<PVector> points = new ArrayList<PVector>();

float step = random(0.01, 0.05); // random step
Folds vector_field = new Folds(); // random vector field
float noise_scale = random(-2,2); // noise scaler

void setup() {
  size(600, 600);
  noStroke();
  smooth(8);
  fill(20, 5);
  background(240);

  for (int i=0; i<50000; i++) {
    points.add(new PVector(random(-2, 2), random(-2, 2)));
  }
}

PVector noise_field(PVector v) {
  float x = v.x * noise_scale;
  float y = v.y * noise_scale;
  PVector field = new PVector(noise(x,y)-0.5, noise(y,x,0.3)-0.5);
  field.mult(2);
  return field;
}

void updateVector(PVector v) {
  
  PVector vf = vector_field.calcField(v,1); // calc vector field
  vf.add(noise_field(v)); // add vector field constructed from noise
  vf.mult(TWO_PI); // multiply 
  
  v.x = v.x + step * sin(vf.x); // main formula
  v.y = v.y + step * sin(vf.y);

  if (abs(v.x)>4 || abs(v.y)>4) {
    v.x = random(-2, 2);
    v.y = random(-2, 2);
  }
}

void draw() {
  for (PVector v : points) {
    updateVector(v);

    float x = map(v.x, -3, 3, 0, width);
    float y = map(v.y, -3, 3, 0, height);

    rect(x, y, 1, 1);
  }
}

void keyPressed() {
  if(keyCode == 32) {
    String name = hex((int)random(0x1000000)) + ".jpg";
    save(name);
    println("saved: " + name);
  }
}

//

class Folds {
  int fold_id;

  Folds(int id) {
    fold_id = id;
    println(getNamebyNo(id));
    precalc();
  }

  Folds() {
    this((int)random(22)+1);
  }

  PVector calcField(PVector p, float weight) {
    switch(fold_id) {
    case 1: 
      return sinusoidal(p, weight); 
    case 2: 
      return butterfly(p, weight); 
    case 3: 
      return wedgejulia(p, weight);
    case 4: 
      return rotate(p, weight); 
    case 5: 
      return cross(p, weight); 
    case 6: 
      return pdj(p, weight); 
    case 7: 
      return fan2(p, weight); 
    case 8: 
      return rings2(p, weight); 
    case 9: 
      return heart(p, weight); 
    case 10: 
      return ex(p, weight); 
    case 11: 
      return popcorn(p, weight);
    case 12: 
      return waves(p, weight); 
    case 13: 
      return polar(p, weight); 
    case 14: 
      return horseshoe(p, weight); 
    case 15: 
      return curl(p, weight); 
    case 16: 
      return scry(p, weight);
    case 17: 
      return rectangles(p, weight);
    case 18: 
      return julian(p, weight);
    case 19: 
      return juliascope(p, weight);
    case 20: 
      return twintrian(p, weight);
    case 21: 
      return lines(p, weight);
    case 22:
      return quilez(p, weight);
    default: 
      return p;
    }
  }

  String getNamebyNo(int no) {
    switch(no) {
    case 1: 
      return "sinusoidal"; 
    case 2: 
      return "butterfly"; 
    case 3: 
      return "wedgejulia";
    case 4: 
      return "rotate"; 
    case 5: 
      return "cross"; 
    case 6: 
      return "pdj"; 
    case 7: 
      return "fan2"; 
    case 8: 
      return "rings2"; 
    case 9: 
      return "heart"; 
    case 10: 
      return "ex"; 
    case 11: 
      return "popcorn";
    case 12: 
      return "waves"; 
    case 13: 
      return "polar"; 
    case 14: 
      return "horseshoe"; 
    case 15: 
      return "curl"; 
    case 16: 
      return "scry";
    case 17: 
      return "rectangles";
    case 18: 
      return "julian";
    case 19: 
      return "juliascope";
    case 20: 
      return "twintrian";
    case 21: 
      return "lines";
    case 22:
      return "quilez";
    default: 
      return "none";
    }
  }

  float t0 = random(-4, 4);
  float t1 = random(-4, 4);
  float t2 = random(-4, 4);
  float t3 = random(-4, 4);

  PVector quilez(PVector v, float weight) {
    return new PVector(weight * cos(t0 + v.y + cos(t1 + PI * v.x)), 
    weight*cos(t2 + v.x + cos(t3 + PI * v.y)));
  }

  float lines_scale = random(0.03, 0.4);
  boolean lines_squared = random(0, 1) < 0.5 ? true : false;

  PVector lines(PVector p, float weight) {
    float r;
    if (lines_squared) r=0.5*sq(randomGaussian());
    else r=0.25*randomGaussian();
    float y = lines_scale * (floor(p.y/lines_scale) - 0.5 + r);

    return new PVector(weight * p.x, weight * y);
  }

  float twintrian_weight = random(0.4, 1);

  PVector twintrian(PVector p, float weight) {
    float a = random(0, 1) * twintrian_weight * p.mag();
    float sa = sin(a);
    float cla = cos(a) + log(sq(sa));
    if (cla<-30) cla = -30;

    return new PVector(weight * 0.8 * p.x * cla, weight * 0.8 * p.x * (cla - sa * PI));
  } 

  float julian_power = random(0, 1)<0.5? (int)random(4, 10) : -(int)random(4, 10);
  float julian_dist = random(0.5, 3.0);
  float julian_cpower, julian_abspower;

  PVector julian(PVector p, float weight) {
    float a = (atan2(p.y, p.x) + TWO_PI * floor(julian_abspower * random(0, 1)))/julian_power;
    float r = weight * 2.0 * pow(sq(p.x)+sq(p.y), julian_cpower);
    return new PVector(r*cos(a), r*sin(a));
  }

  float juliascope_power = random(0, 1)<0.5? (int)random(4, 10) : -(int)random(4, 10);
  float juliascope_dist = random(0.5, 2.0);
  float juliascope_cpower, juliascope_abspower;

  PVector juliascope(PVector p, float weight) {
    int rnd = (int)(juliascope_abspower * random(0, 1));
    float a;
    if (rnd % 2 == 0)
      a = (2 * PI * rnd +atan2(p.y, p.x))/juliascope_power;
    else
      a = (2 * PI * rnd -atan2(p.y, p.x))/juliascope_power;
    float r = weight * 2.0 * pow(sq(p.x)+sq(p.y), juliascope_cpower);
    return new PVector(r*cos(a), r*sin(a));
  }


  float rectangles_x = random(0.1, 1);
  float rectangles_y = random(0.1, 1);

  PVector rectangles(PVector p, float weight) {
    float x = weight * ((2 * floor(p.x/rectangles_x) + 1)* rectangles_x - p.x);
    float y = weight * ((2 * floor(p.y/rectangles_y) + 1)* rectangles_y - p.y);

    return new PVector(x, y);
  }

  float scry_weight = random(0.4, 1);

  PVector scry(PVector p, float weight) {
    float r2 = sq(p.x)*sq(p.y);
    float r = 3.0 / (p.mag() * (r2 + 1.0/scry_weight));
    float x = weight * r * p.x;
    float y = weight * r * p.y;
    return new PVector(x, y);
  }

  float fan2_x = random(-1, 1);
  float fan2_y = random(2, 7);
  float fan2_dx, fan2_dx2;

  PVector fan2(PVector p, float weight) {
    float r = weight * 0.8 * p.mag();
    float theta = atan2(p.x, p.y);
    float t = theta + fan2_y - floor((theta + fan2_y) / fan2_dx) * fan2_dx;
    float ang;
    if (t > fan2_dx2)
      ang = theta - fan2_dx2;
    else
      ang = theta + fan2_dx2;

    return new PVector(r * sin(ang), r * cos(ang));
  }

  float pdj_a = random(-3.0, 3.0);
  float pdj_b = random(-3.0, 3.0);
  float pdj_c = random(-3.0, 3.0);
  float pdj_d = random(-3.0, 3.0);

  PVector pdj(PVector p, float weight) {
    return new PVector( weight * 1.5 * (sin(pdj_a * p.y) - cos(pdj_b * p.x)), 
    weight * 1.5 * (sin(pdj_c * p.x) - cos(pdj_d * p.y)));
  }

  PVector sinusoidal(PVector p, float weight) {
    return new PVector(weight * 3.0 * sin(p.x), 3.0 * sin(p.y));
  }

  PVector butterfly(PVector p, float weight) {
    float y2 = 2.0 * p.y;
    float r = weight * 1.3029400317411197908970256609023 * sqrt(abs(p.y * p.x) / (1e-10 + sq(p.x) + sq(y2)));
    return new PVector(r * p.x, r * y2);
  }

  int wedgejulia_count = (int)random(2, 7);
  float wedgejulia_angle =random(-3, 3);
  int wedgejulia_power = random(0, 1)<0.5?(int)random(2, 7):-(int)random(2, 7);
  float wedgejulia_dist = random(1, 4);
  float wedgejulia_cf, wedgejulia_cn, wedgejulia_rN;

  PVector wedgejulia(PVector p, float weight) {
    float r = weight * pow(sq(p.x)+sq(p.y), wedgejulia_cn);
    int t_rnd = (int) ((wedgejulia_rN) * random(0, 1));
    float a = (atan2(p.y, p.x) + TWO_PI * t_rnd) / wedgejulia_power;
    float c = floor((wedgejulia_count * a + PI) * (1/PI) * 0.5);
    a = a * wedgejulia_cf + c * wedgejulia_angle;

    return new PVector(r * cos(a), r * sin(a));
  }

  PVector rotate(PVector p, float angle) {
    float ca = cos(angle);
    float sa = sin(angle);
    return new PVector(ca * p.x - sa * p.y, sa * p.x + ca * p.y);
  }

  PVector realgaussian(PVector p, float weight) {
    float a = TWO_PI * random(0, 1);
    float r = weight * 3.0 * randomGaussian();
    return new PVector(r*cos(a), r*sin(a));
  }

  PVector cross(PVector p, float weight) {
    float r = sqrt(1.0 / (sq(sq(p.x)-sq(p.y)))+1e-10);
    return new PVector(weight * 0.8 * p.x * r, weight * 0.8 * p.y * r);
  }

  float curl_c1 = random(0.1, 0.7);
  float curl_c2 = random(0.1, 0.7);

  PVector curl(PVector p, float weight) {
    float re = 1 + curl_c1 * p.x + curl_c2 * (sq(p.x)-sq(p.y));
    float im = curl_c1 * p.y + curl_c2 * 2 * p.x * p.y;
    float r = weight / (re * re + im * im);

    return new PVector(r * (p.x * re + p.y * im), r * (p.y * re - p.x * im));
  }

  float rings2_val = random(0.1, 1.2);
  float rings2_val2; 

  PVector rings2(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x, p.y);
    float d = weight*(r - 2.0 * rings2_val2 * floor( (r+rings2_val2)/(2.0 * rings2_val2)) + r * (1.0 - rings2_val2) );
    //float d = weight*(2.0 - rings2_val2 * ((int) ((r / rings2_val2 + 1) / 2) * 2 / r + 1));
    return new PVector(d*sin(theta), d*cos(theta));
  }  

  PVector heart(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.y, p.x);
    float sinr = sin(r * theta);
    float cosr = cos(r * theta);

    return new PVector(weight * r * sinr, -r * weight * cosr);
  }

  PVector ex(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x, p.y);
    float xsin = sin(theta + r);
    float ycos = cos(theta - r);
    float x = weight * 0.7 * r * xsin * xsin * xsin;
    float y = weight * 0.7 * r * ycos * ycos * ycos;
    return new PVector(x+y, x-y);
  }

  float popcorn_c = random(-0.8, 0.8);
  float popcorn_f = random(-0.8, 0.8);

  PVector popcorn(PVector p, float weight) {
    float x = p.x + popcorn_c * sin(tan(3.0 * p.y));
    float y = p.y + popcorn_f * sin(tan(3.0 * p.x));

    return new PVector(weight * 0.85 * x, weight * 0.85 * y);
  }

  float waves_b = random(-0.8, 0.8);
  float waves_e = random(-0.8, 0.8);
  float waves_c = random(-0.8, 0.8);
  float waves_f = random(-0.8, 0.8);

  PVector waves(PVector p, float weight) {
    float x = p.x + waves_b * sin(p.y * (1.0 / (waves_c * waves_c) ));
    float y = p.y + waves_e * sin(p.x * (1.0 / (waves_f * waves_f) ));

    return new PVector(weight * x, weight * y);
  }

  PVector horseshoe(PVector p, float weight) {
    float r = weight / (1.25 * (p.mag() + 1e-10));
    float x = r * ((p.x - p.y) * (p.x + p.y));
    float y = r * 2.0 * p.x * p.y;
    return new PVector(x, y);
  }

  PVector polar(PVector p, float weight) {
    float r = p.mag();
    float theta = atan2(p.x, p.y);
    float x = theta / PI;
    float y = r - 2.0;
    return new PVector(weight * 1.5 * x, weight * 1.5 * y);
  }

  void precalc() {
    wedgejulia_cf = 1.0 - 0.5 / PI * wedgejulia_angle * wedgejulia_count;
    wedgejulia_cn = wedgejulia_dist / wedgejulia_power / 2.0;
    wedgejulia_rN = abs(wedgejulia_power);
    rings2_val2 = rings2_val * rings2_val;
    fan2_dx = PI * fan2_x * fan2_x + 1e-10;
    fan2_dx2 = 0.5 * fan2_dx;
    julian_cpower = julian_dist/julian_power/2.0;
    julian_abspower = abs(julian_power);
    juliascope_cpower = juliascope_dist/juliascope_power/2.0;
    juliascope_abspower = abs(juliascope_power);
  }
}