April 23, 2014

adamkilledeve asked: You sir, are a pioneer. I was wondering if you would be so kind as to make the source code for your chris christie pixel sorting piece available? that would be amazing and helpful. (I am struggling to learn processing, and any help would be greatly appreciated) Thank you!

/*
RGB Sorting

Made in Processing 2.1.2
By Phillip Stearns

A less glitchy approach to pixel sorting.

Part of the glitchiness, or glitch-like look and feel of Kim Asendorf's
brilliant ASDFPixelSort lies in the fact that when you apply the sort()
method to an array of pixels, you're actually sorting according to the
numeric value of that pixel. Processing treats the color of a pixel
as a single 32 bit number, ordered ARGB in 24 bit colorspace w/ alpha.

A 100% opaque red pixel would have the binary representation of
11111111111111110000000000000000
Alpha  |  Red  | Green  | Blue   
^                              ^
|                              |
MSB                           LSB

MSB = most significant bit, like the 9 in 900 for those used to base ten counting
LSB = least significant bit, like the 1 in 5 million and 21.

This also means that red pixel is a bigger number than a green pixel, which
is greater than a blue pixel.

It's not so much based on a perceptual color evaluation; pixel sorting
looks the way it does because the sorting criteria is based on numbers alone,
which don't quite line up with perception. Why things look interesting when you sort pixels this way is
a result of how we use numbers to describe the color of a pixel.

THIS little program sorts the channels separately, which has a slightly
different, smoother effect overall. Rather than sort the pixels according to their ARGB value, RGBsort first breaks up the image into R G B channels, sorts them individually, then recombines them.  Have a look!
*/


PImage sourceImg;
int sortDirection;

void setup(){
  sourceImg = loadImage("random.jpg");
  size(sourceImg.width, sourceImg.height);
  noLoop(); //stops the draw from looping
  sortDirection = 0; //0 sorts all the rows, 1 sorts all the columns
}

void draw(){
  
  //switch lets us do different things for different cases 
  switch(sortDirection) {
    
    //ror sorting
    case 0: 
      for(int row = 0 ; row < sourceImg.height ; row++){
        RGBsortRow(sourceImg, row);
      }
      break;
    
    //column sorting
    case 1: 
      for(int col = 0 ; col < sourceImg.width ; col++){
        RGBsortColumn(sourceImg, col);
      }
      break;
  }
  
  //display the sorted image
  image(sourceImg, 0, 0);  
}


void RGBsortRow(PImage image, int row){
  
  int[] bufferR = new int[image.width];
  int[] bufferG = new int[image.width];
  int[] bufferB = new int[image.width];
  
  //make sure that the row number exists
  if (row < 0 || row >= height){
    //if it doesn't, please let me know
    println("Row value is out of range.");
  } else{
    //otherwise, please sort
    
    for(int i = 0; i < image.width ; i++){
      //basically we're walking through the row specified in the function arguments and separating the RGB values into their respective buffers
      //to do this, we use the bitwise >> or shift right operator and mask the extraneous bits with the & (AND) 0xFF or 11111111
      bufferR[i] = image.pixels[row*image.width+i] >> 16 & 0xFF;
      bufferG[i] = image.pixels[row*image.width+i] >> 8 & 0xFF;
      bufferB[i] = image.pixels[row*image.width+i] & 0xFF;
    }
    
    //sort the pixels in the buffers
    bufferR = sort(bufferR);
    bufferG = sort(bufferG);
    bufferB = sort(bufferB);
    
    //recombine the RGB values using the << shift left and | (OR) operator
    for(int j = 0; j < image.width ; j++){
      image.pixels[row*image.width+j] = (255 << 24) | (bufferR[j] << 16) | (bufferG[j] << 8) | (bufferB[j]);
    } 
  }
}


//the column sorting works in the same manner
void RGBsortColumn(PImage image, int column){
  int[] bufferR = new int[image.height];
  int[] bufferG = new int[image.height];
  int[] bufferB = new int[image.height];
  if (column < 0 || column >= width){
    println("Column value is out of range.");
  } else{
    for(int i = 0; i < image.height ; i++){
      bufferR[i] = image.pixels[i*image.width+column] >> 16 & 0xFF;
      bufferG[i] = image.pixels[i*image.width+column] >> 8 & 0xFF;
      bufferB[i] = image.pixels[i*image.width+column] & 0xFF;
    }
    bufferR = sort(bufferR);
    bufferG = sort(bufferG);
    bufferB = sort(bufferB);
    for(int j = 0; j < image.height ; j++){
      image.pixels[j*image.width+column] = (255 << 24) | (bufferR[j] << 16) | (bufferG[j] << 8) | (bufferB[j]);
    }
  }
}

April 22, 2014

Canyons of flesh, masks of the interior, portraits of fluid geometries, a mathematics of resemblances.

Photographs from my wanderings around the interiors or various portraits found in the 123D Catch community projects.

April 21, 2014

April 21, 2014

April 21, 2014

April 21, 2014

April 20, 2014

Masks and landscapes culled from 3D portraits made using 123d Catch

March 17, 2014

I was curious to see how well images from the High Voltage Image Making project would transfer into textiles, so put together a design file made from the lead image for the Kickstarter campaign and sent it off to the weavers who make my Glitch Textiles.

I’m super pleased with the results and will be making this design available for a limited time, exclusively through the kickstarter campaign as a reward at the $225 level.

Visit the Kickstarter for High Voltage Image Making here!

March 8, 2014

16x16 pixel macroblock compositions extracted from a student post in my Skillshare Class on Databending.

Enroll today. Take it at your own pace. Access for Life:

http://skl.sh/1d2PbFb

March 5, 2014

Details from Retinal Pigment Epithelium

Part of the High Voltage Image Making project on Kickstarter.

February 28, 2014

kickstarter:

We’re currently obsessing over these images from Phillip Stearns’ High Voltage Image Making. The pictures explore the use of strong electrical currents in photography, and they are illuminating. They are powerful. They are positively shocking. 

February 24, 2014

High Voltage Image Making on Kickstarter!

A project exploring the use of electrical discharge as a means of creating images in photographic media.

Materials: 15000 Volt Neon Transformer, Fujifilm FP-100c Instant Color Film

February 24, 2014

Awesome student work from my workshop at Machine Project by Michelle Leonhart  - tinwhiskers.net

(Source: flickr.com)

February 22, 2014
Created for my class on Glitch Art now open for enrollment on Skillshare: http://skl.sh/1eyNzVn

Created for my class on Glitch Art now open for enrollment on Skillshare: http://skl.sh/1eyNzVn

February 17, 2014

yearoftheglitch:

Hey, there! I’m teaching series of Glitch Art courses on Skillshare. Sign up for the Basic Databending class today.

Use this link + code TUMBLR50 for a 50% discount on enrollment: http://skl.sh/1f22nqx (limited to the first 50 students)

Glitch Art - Creating Design from Error: Databending Basics will show you how to use text editors and hex editors to make glitch art and then turn a series of glitched images into an animated GIF. We begin with a brief introduction to what Glitch Art is, the materials involved, and then dive into hacking the materiality of our digital world.

PROJECT CHALLENGE!

Top 5 projects as selected by the class will be featured on my blog, Year of the Glitch!

Enrollment for my online class with Skillshare is open! It’s self-paced and you’ll have permanent access to the course materials once you sign up. REBLOG!