Seam carving - OpenProcessing

mySketch
xxxxxxxxxx
 
/* @pjs preload="IMGP7557.jpg"; */
int w, newWidth;//image original and new width
int h, newHeight;//image original and new height
int[] pix;//modified image pixels array
int[] nrg;//energy pixels array
int[][] columnsX;//columns that were removed
int[][] rowsY;//rows that were removed
color[][] colors;//colors of the removed lines
int[][] energies;//energies of the removed lines
int nbLinesToProcess = 10;
​
void setup() {
  size(650, 433, P2D);
  PImage pimg = loadImage("IMGP7557.jpg");
  w = newWidth = pimg.width;
  h = newHeight = pimg.height;
  pix = new int[w * h];
  nrg = new int[w * h];
  columnsX = new int[w][h];
  rowsY = new int[w][h];
  colors = new color[w][h];
  energies = new int[w][h];
  pimg.loadPixels();
  arrayCopy(pimg.pixels, pix);
  pimg.updatePixels();
​
  computeEnergy();
}
​
int[] findColumn() {
  int minEnergyColumn = 1000000000;//energy of the min energy column
  int nbColumnsToTest = (int)(newWidth/10);//number of columns to compare
  int[] xs = new int[h];//holds the x position of the lowest energy column
  int[] tmpx = new int[h];//holds the x position of the current column
​
  for (int i = 0; i < nbColumnsToTest; i ++) {
    int x = (int)random(1, newWidth-1);
    int energySum = nrg[0 + x], minNrg, nrg0, nrg1, nrg2;
    Boolean touchEdge = false;
​
    tmpx[0] = x;
    for (int y = 1; y < h; y ++) {
      if (x > 0 && x < newWidth-1) {
        nrg0 = nrg[y * w + x - 1];
        nrg1 = nrg[y * w + x];
        nrg2 = nrg[y * w + x + 1];
        minNrg = Math.min(Math.min(nrg0, nrg1), nrg2);
        if (minNrg == nrg0) {
          x -= 1;
        } else if (minNrg == nrg2) {
          x += 1;
        }
        tmpx[y] = x;
        energySum += minNrg;
      } else {
        touchEdge = true;
        break;
      }
    }
    if (!touchEdge && energySum < minEnergyColumn) {
      minEnergyColumn = energySum;
      arrayCopy(tmpx, xs);
    }
  }
​
  return minEnergyColumn < 1000000000 ? xs : null;
}
​
int[] findRow(){
  int minEnergyRow = 1000000000;//energy of the min energy row
  int nbRowsToTest = (int)(newHeight/10);//number of rows to compare
  int[] ys = new int[w];//holds the y position of the lowest energy row
  int[] tmpy = new int[w];//holds the y position of the current row
​
  for (int i = 0; i < nbRowsToTest; i ++) {
    int y = (int)random(1, newHeight-1);
    int energySum = nrg[y * w + 0], minNrg, nrg0, nrg1, nrg2;
    Boolean touchEdge = false;
​
    tmpy[0] = y;
    for (int x = 1; x < w; x ++) {
      if (y > 0 && y < newHeight-1) {
        nrg0 = nrg[(y-1) * w + x];
        nrg1 = nrg[y * w + x];
        nrg2 = nrg[(y+1) * w + x];
        minNrg = Math.min(Math.min(nrg0, nrg1), nrg2);
        if (minNrg == nrg0) {
          y -= 1;
        } else if (minNrg == nrg2) {
          y += 1;
        }
        tmpy[x] = y;
        energySum += minNrg;
      } else {
        touchEdge = true;
        break;
      }
    }
    if (!touchEdge && energySum < minEnergyRow) {
      minEnergyRow = energySum;
      arrayCopy(tmpy, ys);
    }
  }
  return minEnergyRow < 1000000000 ? ys : null;
}
​
void draw() {
  if (mousePressed) {
    int nbLinesToChange =  min (abs(newWidth - mouseX), nbLinesToProcess);
    if (mouseX < newWidth) {
      for (int i = 0; i <nbLinesToChange; i ++) {
        removeOneColumn();
      }
    } else {
      for (int i = 0; i < nbLinesToChange; i ++) {
        addColumn();
      }
    }
  }else if (keyPressed && key == CODED) {
    if ((keyCode == LEFT || keyCode == RIGHT) && newHeight == h) {
      for (int k = 0; k < nbLinesToProcess; k ++) {
        if (keyCode == LEFT) removeOneColumn();
        else addColumn();
      }
    } else if ((keyCode == UP || keyCode == DOWN) && newWidth == w) {
      for (int k = 0; k < nbLinesToProcess; k ++) {
        if (keyCode == UP) removeOneRow(); 
        else addRow();
      }
    }
  }
  
  loadPixels();
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      if(x < w && y < h){
        pixels[y * width + x] = pix[y * w + x];//display the image
      }else{
        pixels[y * width + x] = 0;
      }
    }
  }
  updatePixels();
}
​
void removeOneColumn() { 
  int[] xs = findColumn();
  if (xs != null) {
    removeThisColumn(xs);
  }
}
​
void removeOneRow() { 
  int[] ys = findRow();
  if (ys != null) {
    removeThisRow(ys);
  }
}
​
void removeThisColumn(int[] xs) {
  for (int y = 0; y < h; y++) {
    //store the erased column info, needed when column is drawn back
    columnsX[w - newWidth][y] = xs[y];//store the x coords of the column that will be erased
    colors[w - newWidth][y] = pix[y * w + xs[y]];//store the colors of the column that will be erased
    energies[w - newWidth][y] = nrg[y * w + xs[y]];//store the energies of the column that will be erased
    for (int x = xs[y]; x < newWidth-1; x++) {
      pix[y * w + x] = pix[y * w + x + 1]; 
      nrg[y * w + x] = nrg[y * w + x + 1];
    }
    pix[y * w + newWidth - 1] = 0;
    nrg[y * w + newWidth - 1] = 0;
  }
  newWidth --;
}
​
void removeThisRow(int[] ys) {
  for (int x = 0; x < w; x++) {
    //store the erased row info, needed when row is drawn back
    rowsY[x][h - newHeight] = ys[x];//store the x coords of the row that will be erased
    colors[x][h - newHeight] = pix[ys[x] * w + x];//store the colors of the row that will be erased
    energies[x][h - newHeight] = nrg[ys[x] * w + x];//store the energies of the row that will be erased
    for (int y = ys[x]; y < newHeight-1; y++) {
      pix[y * w + x] = pix[(y+1) * w + x]; 
      nrg[y * w + x] = nrg[(y+1) * w + x];
    }
    pix[(newHeight-1) * w + x] = 0;
    nrg[(newHeight-1) * w + x] = 0;
  }
  newHeight --;
}
​
void addColumn() {
  if (newWidth < w) {
    for (int y = 0; y < h; y++) {
      for (int x = newWidth-1; x >= columnsX[w - newWidth - 1][y]; x--) {
        pix[y * w + x + 1] = pix[y * w + x]; 
        nrg[y * w + x + 1] = nrg[y * w + x];
      }
      pix[y * w + columnsX[w - newWidth - 1][y]] = color(colors[w - newWidth - 1][y]);
      nrg[y * w + columnsX[w - newWidth - 1][y]] = energies[w - newWidth - 1][y];
    }
    newWidth ++;
  }
}
​
void addRow() {
  if (newHeight < h) {
    for (int x = 0; x < w; x++) {
      for (int y = newHeight-1; y >= rowsY[x][h - newHeight - 1]; y--) {
        pix[(y+1) * w + x] = pix[y * w + x]; 
        nrg[(y+1) * w + x] = nrg[y * w + x];
      }
      pix[rowsY[x][h - newHeight - 1] * w + x] = color(colors[x][h - newHeight - 1]);
      nrg[rowsY[x][h - newHeight - 1] * w + x] = energies[x][h - newHeight - 1];
    }
    newHeight ++;
  }
}
​
void computeEnergy() {
  color cLeft, cRight;
  float dr, dg, db, d;
  for (int x = 1; x < w-1; x++) {
    for (int y = 1; y < h-1; y++) {
      cLeft = pix[y * w + x - 1];
      cRight = pix[y * w + x + 1];
      dr = red(cRight) - red(cLeft);
      dg = green(cRight) - green(cLeft);
      db = blue(cRight) - blue(cLeft);
      d = dr*dr + dg*dg + db*db;
​
      cLeft = pix[(y+1) * w + x];
      cRight = pix[(y-1) * w + x];
      dr = red(cRight) - red(cLeft);
      dg = green(cRight) - green(cLeft);
      db = blue(cRight) - blue(cLeft);
      d += dr*dr + dg*dg + db*db;
​
      nrg[w * y + x] = (int)d;
    }
  }
}