//#######################################################################
//######## Modify those parameters to fit your needs ####################
//#######################################################################
 
// how many quads to draw in total
int totalItems = 10000; // the total amount is not neccessarily the amount of displayed quads because the algorithm hides quads which are the initial size of 1 because those can be the ones inside other quads
 
// the scale factor (increase it to see faster but more overlapping results, decrease it to see slower but more precise result)
float scaleFactor = 0.5;
 
// part size e.g. how many quads to produce and scale in each run
int partSize = 50;
 
// image to use
String inputImagePath = "input/image.jpg";
 
// image to produce
String outputImagePath = "output/image.jpg";
 
// screen size if your excepting to use/produce larger images than screen resolution ...increase those values
int screenWidth = 1280;
int screenHeight = 1024;
 
//#######################################################################
//######## No need to change something below ############################
//#######################################################################
 
// array to hold all drawn quads
Space[] rects;
 
// neutral initial scaling factor 
float scaling = 1;
 
// image to base the average color collection on
PImage img;
 
// used to determine if a part run is finished to start a new one
boolean partFinished = false;
 
// used to check if the total processing is finished
boolean finished = false;
 
// use key S to switch if the input image will be shown or not
boolean showImage = true;
 
// uncomment to hide window gui
/*
public void init() {
  frame.removeNotify();
  frame.setUndecorated(true);
  frame.addNotify();
  super.init();
} 
*/
 
public void setup()
{
  size(screenWidth, screenHeight);
 
  // if window gui is hidden position the scene
  //frame.setLocation(0, 0);
 
  // init quad array
  rects = new Space[totalItems];
 
  // load the image to use
  img = loadImage(inputImagePath);
 
  // build the first amount of quads
  for (int i = 0; i < partSize;i++) {
    float x = random(0, img.width);
    float y = random(0, img.height);
    rects[i] = new Space(x, y, x+1, y+1);
  }
 
}
 
public void draw()
{
  background(0);
  // hide or show input image
  if (showImage) {
    image(img, 0, 0);
  }
  if (!finished) {
    loadPixels();
    img.loadPixels(); 
    // when the last group of quads is finished start a new one
    if (partFinished) {
      for (int i = partSize; i < partSize + partSize && i < rects.length-1; i++) {
        float x = random(0, screenWidth);
        float y = random(0, screenHeight);
        rects[i] = new Space(x, y, x+1, y+1);
      }
      partSize += partSize;
      // reset scaling factor to start from
      scaling = 1;
    }
    // loop over every available quad
    for (int i = 0; i < partSize && i < rects.length-1 ;i++) {
      // check if the quad already intersects another quad to speed up things e.g. draw it right away
      if ( !rects[i].getIntersect()) {
        // if it doesn't intersect before loop over every quad except the current one to check for intersection
        for (int k = 0; k < partSize && k < rects.length-1 ;k++) {
          if (i != k && rectRectIntersect(rects[i].getUpLeft().x, rects[i].getUpLeft().y, rects[i].getUpLeft().x + rects[i].getWidth(), rects[i].getUpLeft().y + rects[i].getHeight(), rects[k].getUpLeft().x, rects[k].getUpLeft().y, rects[k].getUpLeft().x + rects[k].getWidth(), rects[k].getUpLeft().y+rects[k].getHeight()) == true) {
            // set status if intersection occured
            rects[i].setIntersect(true);
            //break;
          }
        }
        // when the current quad doesn't intersect with an other, scale it and recalculate average image color in quad range
        if (!rects[i].getIntersect()) {
          // scale
          rects[i].setScaling(scaling);
          // average color
          int r = 0;
          int g = 0;
          int b = 0;
          int count = 0;
          // loop over every pixel in the quad
          for (int x = (int)rects[i].getUpLeft().x; x < ((int)rects[i].getUpLeft().x + (int)rects[i].getWidth()); x++) {
            for (int y = (int)rects[i].getUpLeft().y; y < ((int)rects[i].getUpLeft().y + (int)rects[i].getHeight()); y++) {
              // pixel position to get color values from
              int loc = (int)(x + y * img.width);
              try {
                // add color values
                r += red(img.pixels[loc]);
                g += green(img.pixels[loc]);
                b += blue(img.pixels[loc]);
                // pixel amount of the quad
                count++;
              } 
              catch (ArrayIndexOutOfBoundsException e) {
                // might occur that pixels outside the image get selected, catch that here
              }
            }
          }
          if (count > 0) {
            // get the average color values by deviding by the pixel amount
            r = round(r / count);
            g = round(g / count);
            b = round(b / count);
            // save the colors to use it when the scaling is finished
            rects[i].setColor((int)r, (int)g, (int)b);
          }
        }
      }
      // not quite accurate but here we prevent all unwanted quads (e.g. the ones inside other quads) to be drawn, most of them are in size equal to 1 which is the initial size
      if (rects[i].getWidth() > 1) {
        // use saved average color to fill quad
        fill(rects[i].getColor());
        // draw quad
        rect(rects[i].getUpLeft().x, rects[i].getUpLeft().y, rects[i].getWidth(), rects[i].getHeight());
      }
    }
 
    partFinished = true;
    // determine if all quads for the current round are finished
    for (int j = 0; j < partSize && j < rects.length-1;j++) {
      if (!rects[j].getIntersect()) {
        partFinished = false;
      }
    }
    //scale up
    scaling += scaleFactor;
 
    if (partSize > totalItems) {
      finished = true;
      // everything is done...save the image
      PImage partial = get(0,0,img.width,img.height);
      partial.save(outputImagePath);
    }
  } 
  else {
    // everything is finished ... only drawing is left
    for (int i = 0; i < rects.length-1 ;i++) {
      if (rects[i].getWidth() > 1) {
        // use saved average color to fill quad
        fill(rects[i].getColor());
        // draw quad
        rect(rects[i].getUpLeft().x, rects[i].getUpLeft().y, rects[i].getWidth(), rects[i].getHeight());
      }
    }
  }
}
 
void keyReleased() {
  if (key == 's' || key == 'S') {
    showImage = (showImage == true) ? false : true;
  }
}
// compares intersection between two quads and input image borders
boolean rectRectIntersect(float left, float top, float right, float bottom, float otherLeft, float otherTop, float otherRight, float otherBottom) {
  return !(left >= otherRight || right <= otherLeft || top >= otherBottom || bottom <= otherTop) || (right >= img.width || bottom >= img.height);
}
 
// Helper class to save coordinates, scaling, color and intersection status of a quad
public class Space {
  // the up left corner of the quad
  float upLeftX;
  float upLeftY;
 
  // the down right corner of the quad
  float downRightX;
  float downRightY;
 
  // the scale factor for the quad
  float scaling;
 
  // color values
  int r;
  int g;
  int b;
 
  // intersection status to determine if this quad intersected an other quad
  boolean intersected;
 
  // constructor
  Space(float x1, float y1, float x2, float y2) {
    upLeftX = x1;
    upLeftY = y1;
    downRightX = x2;
    downRightY = y2;
    // 1 = no scaling
    scaling = 1;
    // no intersection yet
    intersected = false;
    // initial color
    r = g = b = 0;
  }
 
  // set the color
  public void setColor(int newR, int newG, int newB) {
    r = newR;
    g = newG;
    b = newB;
  }
 
  // get the color
  public color getColor() {
    return color(r, g, b);
  }
 
  // set the intersection status
  public void setIntersect(boolean i) {
    intersected = i;
  }
 
  // get the intersection status
  public boolean getIntersect() {
    return intersected;
  }
 
  // set the scaling for the quad
  public void setScaling(float s) {
    scaling = s;
  }
 
  // get the up left corner
  public PVector getUpLeft() {
    return new PVector(upLeftX, upLeftY);
  }
 
  // get the down right corner
  public PVector getDownRight() {
    return new PVector(downRightX, downRightY);
  }
 
  // get the width
  public float getWidth() {
    return (downRightX - upLeftX) * scaling;
  }
 
  // get the height
  public float getHeight() {
    return (downRightY - upLeftY) * scaling;
  }
}