weighted_delaunay.pde

/*
 Modified from SVG Stipple Generator, v. 2.02
 Copyright (C) 2012 by Windell H. Oskay, www.evilmadscientist.com
 
 Full Documentation: http://wiki.evilmadscience.com/StippleGen
 Blog post about the release: http://www.evilmadscientist.com/go/stipple2
 
 An implementation of Weighted Voronoi Stippling:
 http://mrl.nyu.edu/~ajsecord/stipples.html
 
 Inspired by Delaunay Raster http://jonathanpuckey.com/projects/delaunay-raster/
 
*******************************************************************************

/*  
 * 
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * http://creativecommons.org/licenses/LGPL/2.1/
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
import toxi.geom.*;
import toxi.geom.mesh2d.*;

int FRAME_RATE = 30;
String SOURCE_FILE_NAME = "img.jpg";
int MAX_PARTICLES_NUMBER = 1000;
float BRIGHTNESS_CUTOFF = 0;
int CELL_BUFFER = 200;
int CONTRAST = 10;

int MAIN_WIDTH = 800; 
int MAIN_HEIGHT = 600;
int BORDER_WIDTH = 6;

int lowBorderX;
int highBorderX;
int lowBorderY;
int highBorderY;

int generation; 
int voronoiPointsNumber;
boolean isVoronoiCalculated;

Voronoi voronoi; 
Polygon2D regionList[];
PolygonClipper2D clip;

int totalCellsNumber;
int calculatedCellsNumber;
int lastCalculatedCellsNumber;

PImage img;
PImage imgLoad;
PImage imgBlur; 
Vec2D[] particles;

void loadImageAndScale(String fileName, int targetWidth, int targetHeight) {
  int tempX = 0;
  int tempY = 0;

  img = createImage(targetWidth, targetHeight, RGB);
  imgBlur = createImage(targetWidth, targetHeight, RGB);

  img.loadPixels();

  for (int i = 0; i < img.pixels.length; i++) {
    img.pixels[i] = color(255);
  }

  img.updatePixels();
  imgLoad = loadImage(fileName);

  if ((imgLoad.width > targetWidth) || (imgLoad.height > targetWidth)) {
    if (((float)imgLoad.width / (float)imgLoad.height) > ((float)targetWidth / (float)targetHeight)) { 
      imgLoad.resize(targetWidth, 0);
    }
    else { 
      imgLoad.resize(0, targetHeight);
    }
  } 

  if (imgLoad.width < (targetWidth - 2)) {
    tempX = (int)((targetWidth - imgLoad.width ) / 2) ;
  }
  
  if (imgLoad.height < (targetHeight - 2)) { 
    tempY = (int)((targetHeight - imgLoad.height ) / 2) ;
  }

  img.copy(imgLoad, 0, 0, imgLoad.width, imgLoad.height, tempX, tempY, imgLoad.width, imgLoad.height);
  imgBlur.copy(img, 0, 0, img.width, img.height, 0, 0, img.width, img.height);
  imgBlur.filter(BLUR, 1);
  imgBlur.loadPixels();
}

void setupMainArray(int startX, int startY, int lengthX, int lengthY) { 
  particles = new Vec2D[MAX_PARTICLES_NUMBER];

  int  i = 0;
  float x;
  float y;
  float b;
  while (i < MAX_PARTICLES_NUMBER) {
    x = startX + random(lengthX);
    y = startY + random(lengthY);
    b = brightness(imgBlur.pixels[floor(y)*imgBlur.width + floor(x)])/255; 
    if (random(1) >= b) {  
      Vec2D p = new Vec2D(x, y);
      particles[i] = p;  
      i++;
    }
  }

  generation = 0;
  isVoronoiCalculated = false;
  calculatedCellsNumber = 0;
  voronoiPointsNumber = 0;
  voronoi = new Voronoi();
} 

void setup() {
  size(MAIN_WIDTH, MAIN_HEIGHT, P2D);

  lowBorderX =  BORDER_WIDTH;
  highBorderX = MAIN_WIDTH - BORDER_WIDTH;
  lowBorderY = BORDER_WIDTH;
  highBorderY = MAIN_HEIGHT - BORDER_WIDTH;

  int innerWidth = MAIN_WIDTH - 2 * BORDER_WIDTH;
  int innerHeight = MAIN_HEIGHT - 2 * BORDER_WIDTH;

  clip = new SutherlandHodgemanClipper(new Rect(lowBorderX, lowBorderY, innerWidth, innerHeight));

  loadImageAndScale(SOURCE_FILE_NAME, MAIN_WIDTH, MAIN_HEIGHT);
  setupMainArray(lowBorderX, lowBorderY, innerWidth, innerHeight);
  
  frameRate(FRAME_RATE);
  noStroke();
  smooth();
}

void draw() {
  updateParticles();
  drawDelaunay();
}

void updateParticles() {
  if (!isVoronoiCalculated) {
    calculateVoronoi();
  }
  else {
    calculateCells();
  }
}

void calculateVoronoi() {
  if (voronoiPointsNumber == 0) {
    voronoi = new Voronoi();
  }

  int tempPointsNumber = voronoiPointsNumber + 100;
  if (tempPointsNumber > MAX_PARTICLES_NUMBER) {
    tempPointsNumber = MAX_PARTICLES_NUMBER;
  }
  
  int i;
  for (i = voronoiPointsNumber; i < tempPointsNumber; i++) {  
    voronoi.addPoint(new Vec2D(particles[i].x, particles[i].y));
    voronoiPointsNumber++;
  }   

  if (voronoiPointsNumber >= MAX_PARTICLES_NUMBER) {
    totalCellsNumber =  voronoi.getRegions().size();
    voronoiPointsNumber = 0;
    calculatedCellsNumber = 0;
    lastCalculatedCellsNumber = 0;

    regionList = new Polygon2D[totalCellsNumber];

    i = 0;
    for (Polygon2D poly : voronoi.getRegions()) {
      regionList[i++] = poly;
    }
    isVoronoiCalculated = true;
  }
}

void calculateCells() {
  int tempCellsNumber = calculatedCellsNumber + 50;

  if (tempCellsNumber > totalCellsNumber) {
    tempCellsNumber = totalCellsNumber;
  }

  float maxX = 0;
  float minX = MAIN_WIDTH;
  float maxY = 0;
  float minY = MAIN_HEIGHT;
  float tx, ty;
  for (int i=calculatedCellsNumber; i < tempCellsNumber; i++) {  
    Polygon2D region = clip.clipPolygon(regionList[i]);
    for (Vec2D v : region.vertices) { 
      tx = v.x;
      ty = v.y;

      if (tx < minX)
        minX = tx;
      if (tx > maxX)
        maxX = tx;
      if (ty < minY)
        minY = ty;
      if (ty > maxY)
        maxY = ty;
    }

    float diffX = maxX - minX;
    float diffY = maxY - minY;
    float maxSize = max(diffX, diffY);
    float minSize = min(diffX, diffY);
    float scaleFactor = 1.0;

    while (maxSize > CELL_BUFFER) {
      scaleFactor *= 0.5;
      maxSize *= 0.5;
    }

    while (maxSize < (CELL_BUFFER/2)) {
      scaleFactor *= 2;
      maxSize *= 2;
    }  

    if ((minSize * scaleFactor) > (CELL_BUFFER/2)) {   
      scaleFactor *= 0.5;
    }

    float stepSize = (1/scaleFactor);

    float sumX = 0;
    float sumY = 0;
    float sumD = 0;       
    float pictureDensity = 1.0;

    for (float x=minX; x<=maxX; x+=stepSize) {
      for (float y=minY; y<=maxY; y+=stepSize) {
        Vec2D p0 = new Vec2D(x, y);
        if (region.containsPoint(p0)) {
          pictureDensity = 255.001 - (brightness(imgBlur.pixels[ round(y)*imgBlur.width + round(x) ]));  
          sumX += pictureDensity * x;
          sumY += pictureDensity * y; 
          sumD += pictureDensity;
        }
      }
    }  

    if (sumD > 0) {
      sumX /= sumD;
      sumY /= sumD;
    }

    Vec2D center;
    float tempX = sumX;
    float tempY = sumY;
    if ((tempX <= lowBorderX) || (tempX >= highBorderX) || (tempY <= lowBorderY) || (tempY >= highBorderY)) {
      center = region.getCentroid(); 
      tempX = center.x;
      tempY = center.y;

      if (tempX <= lowBorderX)
        tempX = lowBorderX + 1; 
      if (tempX >= highBorderX)
        tempX = highBorderX - 1; 
      if (tempY <= lowBorderY)
        tempY = lowBorderY + 1; 
      if (tempY >= highBorderY)
        tempY = highBorderY - 1;
    }
    
    particles[i].x = tempX;
    particles[i].y = tempY;
    calculatedCellsNumber++;
  } 

  if (calculatedCellsNumber >= totalCellsNumber) {
    isVoronoiCalculated = false; 
    generation++;
  }
}

void drawDelaunay() {
  background(255);
  beginShape(TRIANGLE);
  int r, g, b;
  color c;
  Vec2D v;
  int ca, cb, cc;
  int brightness;
  for (Triangle2D t : voronoi.getTriangles()) {
    if (!isInsideBounds(t.a, t.b, t.c)) continue;
    
    v = t.computeCentroid();
    c = imgBlur.get((int)v.x, (int)v.y);
    r = (int)red(c);
    g = (int)green(c);
    b = (int)blue(c);
    fill(r + CONTRAST, g + CONTRAST, b + CONTRAST);
    vertex(t.a.x, t.a.y);
    fill(r, g, b);
    vertex(t.b.x, t.b.y);
    fill(r - CONTRAST, g - CONTRAST, b - CONTRAST);
    vertex(t.c.x, t.c.y);
  }
  endShape();
}

boolean isInsideBounds(Vec2D a, Vec2D b, Vec2D c) {
  if (a.x < 0 || a.x > width || a.y < 0 || a.y > height ||
    b.x < 0 || b.y < 0 || b.x > width || b.y > height ||
    c.x < 0 || c.y < 0 || c.x > width || c.y > height) {
    return false;
  }
  return true;
}