// Brightness Tracking + PDF
// Combines the Prightness Tracking demo 
// with the PDF Pause/Record demo.
// see http://www.processing.org/reference/libraries/pdf/index.html
 
import processing.video.*;
import processing.pdf.*;
 
Capture video;
boolean recording;
PGraphicsPDF pdf;
int pBrightestX;
int pBrightestY;
 
 
void setup() {
  size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
  // Uses the default video input, see the reference if this causes an error
  video = new Capture(this, width, height, 30);
  noStroke();
  smooth();
 
  recording = false;
  pdf = (PGraphicsPDF) createGraphics(width, height, PDF, "pause-resume.pdf");
 
}
 
void draw() {
 
 
  if (video.available()) {
    video.read();
    //image(video, 0, 0, width, height); // Draw the webcam video onto the screen
    int brightestX = 0; // X-coordinate of the brightest video pixel
    int brightestY = 0; // Y-coordinate of the brightest video pixel
    float brightestValue = 0; // Brightness of the brightest video pixel
    // Search for the brightest pixel: For each row of pixels in the video image and
    // for each pixel in the yth row, compute each pixel's index in the video
    video.loadPixels();
    int index = 0;
    for (int y = 0; y < video.height; y++) {
      for (int x = 0; x < video.width; x++) {
        // Get the color stored in the pixel
        int pixelValue = video.pixels[index];
        // Determine the brightness of the pixel
        float pixelBrightness = brightness(pixelValue);
        // If that value is brighter than any previous, then store the
        // brightness of that pixel, as well as its (x,y) location
        if (pixelBrightness > brightestValue) {
          brightestValue = pixelBrightness;
          brightestY = y;
          brightestX = x;
        }
        index++;
      }
    }
    // draw a line to trace
    line(pBrightestX, pBrightestY, brightestX, brightestY);
 
    pBrightestX = brightestX;
    pBrightestY = brightestY;
 
  }
 
 
 
 
}
 
void keyPressed() {
  if (key == 'r') {
    if (recording) {
      endRecord();
      println("Recording stopped.");
      recording = false;
    } else {
      beginRecord(pdf);
      println("Recording started.");
      recording = true;
    }
  } else if (key == 'q') {
    if (recording) {
      endRecord();
    }
    exit();
  }  
}

// Thresholded video image; 
// Contour traced for the first white blob
import processing.video.*;
 
color black = color(0);
color white = color(255);
int numPixels;
Capture video;
 
int MAX_CHAIN_LEN = 10000;
int chainLength = 0;
Point2d firstPixel;
Point2d chain[];
 
void setup() {
  size(640, 480); // Change size to 320 x 240 if too slow at 640 x 480
  strokeWeight(5);
  // Uses the default video input, see the reference if this causes an error
  video = new Capture(this, width, height, 24);
  numPixels = video.width * video.height;
  noCursor();
  smooth();
 
  firstPixel = new Point2d();
  chain = new Point2d[MAX_CHAIN_LEN];
  for (int i=0; i<MAX_CHAIN_LEN; i++){
    chain[i] = new Point2d();
  }  
}
 
void draw() {
  if (video.available()) {
    video.read();
    video.loadPixels();
    int threshold = 127; // Set the threshold value
    float pixelBrightness; // Declare variable to store a pixel's color
    // Turn each pixel in the video frame black or white depending on its brightness
    loadPixels();
    for (int i = 0; i < numPixels; i++) {
      pixelBrightness = brightness(video.pixels[i]);
      if (pixelBrightness > threshold) { // If the pixel is brighter than the
        pixels[i] = white; // threshold value, make it white
      } 
      else { // Otherwise,
        pixels[i] = black; // make it black
      }
    }
    updatePixels();
 
 
    //-------------------------------------
    // CHAIN CODE (Contour Tracing)
    findFirstPixel();
    chain8 (firstPixel.x, firstPixel.y);
 
    strokeWeight(3);
    stroke(255,0,0); 
    noFill();
    beginShape();
    for (int i=0; i<chainLength; i++){
      vertex(chain[i].x, chain[i].y); 
    }
    endShape();
 
 
  }
}
 
//----------------------------------------------------
// compute chain code to trace edge of a blob.
// this code only traces the first blob found, 
// where "first" is defined as "having a pixel with a lower index" (i.e. higher and to the left).
// for multi-blobs, separate code would be needed to label connected blobs first.
// (i.e. "connected component labelling").
 
//===============================================
class Point2d {
  int x,y;
}
 
 
//===============================================
int bri (int pixval){
  // compute the brightness of a pixel, as the average of the R,G,B values.
  int r = (pixval & 0x00FF0000) >> 16; 
  int g = (pixval & 0x0000FF00) >> 8; 
  int b = (pixval & 0x000000FF); 
  return (r+g+b)/3;
}
 
//===============================================
void findFirstPixel(){
  // find the first pixel of the first lit blob.
  boolean foundFirst = false;
  for (int y=0; y<height; y++){
    for (int x=0; x<width; x++){
      int val = pixels[y*width + x];
      if (!foundFirst && bri(val) > 0){
        firstPixel.x = x;
        firstPixel.y = y;
        foundFirst = true;
      }
    }
  }
}
 
//===============================================
boolean range (int n, int m){
  if (n < 0 || n >= width) return false;
  if (m < 0 || m >= height) return false;
  return true;
}
 
//===============================================
/*	Compute the chain code of the object beginning at pixel (i,j).
 	Return the code as NN integers in the array C.			*/
void chain8 (int i, int j){
  int val,n,m,q,r, ii, d, dii;
  int lastdir, jj;
 
  // Table given index offset for each of the 8 directions.	
  int di[] = {
    0,-1,-1,-1,0,1,1,1                  };
  int dj[] = {
    1,1,0,-1,-1,-1,0,1                  };
 
  for (ii=0; ii<MAX_CHAIN_LEN; ii++) {
    chain[ii].x = 0;
    chain[ii].y = 0;
  }
  val = pixels[j*width+i];	
  chainLength = 0;
  n = 0; /* Initialize for starting pixel */
  q = i;	
  r = j;  
  lastdir = 4;
 
  do {
    m = 0;
    dii = -1;	
    d = 100;
    for (ii=lastdir+1; ii<lastdir+8; ii++) { 	/* Look for next */
      jj = ii%8;
      if (range(di[jj]+q, dj[jj]+r)){
        if ( pixels[(dj[jj]+r)*width + (di[jj]+q)] == val) {
          dii = jj;	
          m = 1;
          break;
        } 
      }
    }
 
    if (m != 0) { /* Found the next pixel ... */
      if (n<MAX_CHAIN_LEN) {
        chain[n].x = q;
        chain[n].y = r;
        n++;
      }
      q += di[dii];	
      r += dj[dii];
      lastdir = (dii+5)%8;
    } 
    else {
      break; 	/* NO next pixel */
    }
    if (n>MAX_CHAIN_LEN) break;
  } 
  while ( (q!=i) || (r!=j) ); 	/* Stop when next to start pixel */
  chainLength = n;
}

// compute chain code to trace edge of a blob.
// this code only traces the first blob found, 
// where "first" is defined as "having a pixel with a lower index" (i.e. higher and to the left).
// for multi-blobs, separate code would be needed to label connected blobs first.
// (i.e. "connected component labelling").
 
int MAX_CHAIN_LEN = 1000;
int chainLength = 0;
Point2d firstPixel;
Point2d chain[];
 
//===============================================
void setup(){
  size(400,400);
 
  firstPixel = new Point2d();
  chain = new Point2d[MAX_CHAIN_LEN];
  for (int i=0; i<MAX_CHAIN_LEN; i++){
    chain[i] = new Point2d();
  }  
}
 
//===============================================
class Point2d {
  int x,y;
}
 
 
//===============================================
void draw(){
 
  background(0);
  noStroke();
  fill(255);
  ellipse(mouseX,mouseY,140,150); 
  ellipse(230,200,100,70); 
  ellipse(280,190,60,120);
  strokeWeight(3);
  stroke(255,0,0); 
  noFill();
 
  loadPixels();
  findFirstPixel();
  chain8 (firstPixel.x, firstPixel.y);
 
  beginShape();
  for (int i=0; i<chainLength; i++){
    vertex(chain[i].x, chain[i].y); 
  }
  endShape();
 
}
 
//===============================================
int bri (int pixval){
  int r = (pixval & 0x00FF0000) >> 16; 
  int g = (pixval & 0x0000FF00) >> 8; 
  int b = (pixval & 0x000000FF); 
  return (r+g+b)/3;
}
 
//===============================================
void findFirstPixel(){
  boolean foundFirst = false;
  for (int y=0; y<height; y++){
    for (int x=0; x<width; x++){
      int val = pixels[y*width + x];
      if (!foundFirst && bri(val) > 0){
        firstPixel.x = x;
        firstPixel.y = y;
        foundFirst = true;
      }
    }
  }
}
 
//===============================================
boolean range (int n, int m){
  if (n < 0 || n >= width) return false;
  if (m < 0 || m >= height) return false;
  return true;
}
 
//===============================================
/*	Compute the chain code of the object beginning at pixel (i,j).
 	Return the code as NN integers in the array C.			*/
void chain8 (int i, int j){
  int val,n,m,q,r, ii, d, dii;
  int lastdir, jj;
 
  // Table given index offset for each of the 8 directions.	
  int di[] = {
    0,-1,-1,-1,0,1,1,1                  };
  int dj[] = {
    1,1,0,-1,-1,-1,0,1                  };
 
  for (ii=0; ii<MAX_CHAIN_LEN; ii++) {
    chain[ii].x = 0;
    chain[ii].y = 0;
  }
  val = pixels[j*width+i];	
  chainLength = 0;
  n = 0; /* Initialize for starting pixel */
  q = i;	
  r = j;  
  lastdir = 4;
 
  do {
    m = 0;
    dii = -1;	
    d = 100;
    for (ii=lastdir+1; ii<lastdir+8; ii++) { 	/* Look for next */
      jj = ii%8;
      if (range(di[jj]+q, dj[jj]+r)){
        if ( pixels[(dj[jj]+r)*width + (di[jj]+q)] == val) {
          dii = jj;	
          m = 1;
          break;
        } 
      }
    }
 
    if (m != 0) { /* Found the next pixel ... */
      if (n<MAX_CHAIN_LEN) {
        chain[n].x = q;
        chain[n].y = r;
        n++;
      }
      q += di[dii];	
      r += dj[dii];
      lastdir = (dii+5)%8;
    } 
    else {
      break; 	/* NO next pixel */
    }
    if (n>MAX_CHAIN_LEN) break;
  } 
  while ( (q!=i) || (r!=j) ); 	/* Stop when next to start pixel */
  chainLength = n;
}

 
color C = color (74,213,112,255); // R,G,B,A
 
long t0 = millis();
for (int i=0; i<786432; i++){
  int R = (C & 0x00FF0000) >> 16;
  int G = (C & 0x0000FF00) >>  8;
  int B = (C & 0x000000FF)      ;
}
println (millis() - t0);
 
long t1 = millis();
for (int i=0; i<786432; i++){
  float r = red(C);
  float g = green(C);
  float b = blue(C);
}
println (millis() - t1);

void setup(){
  size (400,300); 
}
 
void draw (){
  background (255,200,200);
  smooth ();
  strokeWeight (5);
  line (200,150, mouseX, mouseY);
}

PImage cat;
void setup(){
  size (400,300);
  cat = loadImage("Kitty.jpg");
}
 
void draw (){
  for (int i=0; i<500; i++){
    int rx = (int)random(cat.width);
    int ry = (int)random(cat.height);
    int index = ry*cat.width + rx;
 
    color C = cat.pixels[index];
    float Cr = red   (C);
    float Cg = green (C);
    float Cb = blue  (C);
    fill (Cr, Cg, Cb); 
    noStroke();
    ellipse (rx,ry, 15,15  );
  }
}

PImage cat;
void setup(){
  size (400,400,P3D);
  cat = loadImage("Kitty.jpg");
  strokeWeight(3);
}
 
void draw (){
  for (int i=0; i<500; i++){
    int rx = (int)random(60, cat.width - 60);
    int ry = (int)random(60, cat.height - 60);
    int index = ry*cat.width + rx;
    int sx = rx + (int) random(-60,60);
    int sy = ry + (int) random(-60,60);
    int index2 = sy*cat.width + sx;
 
    color C = cat.pixels[index];
    float Cr = red   (C);
    float Cg = green (C);
    float Cb = blue  (C); 
    color D = cat.pixels[index2];
    float Dr = red   (D);
    float Dg = green (D);
    float Db = blue  (D);  
 
    beginShape();
    stroke(Cr,Cg,Cb);
    vertex(rx,ry);
    stroke(Dr,Dg,Db);
    vertex(sx,sy);
    endShape();
  }
}

size(300,400, P3D);
strokeWeight(10);
 
beginShape();
stroke(255,0,0);
vertex(30,30);
stroke(0,255,0);
vertex(120,180);
endShape();

 
int array[];
array = new int[5];
array[0] = 666;
array[1] = 1;
array[2] = 2;
array[3] = 3;
array[4] = 4;
 
// ROTATE RIGHT
int temp = array[array.length-1];
for (int i=(array.length-1); i>0; i--){
  array[i] = array[i-1];
}
array[0] = temp;
 
// ROTATE LEFT
int temp = array[0];
for (int i=0; i< (array.length-1) ; i++){
  array[i] = array[i+1];
}
array[array.length-1] = temp;

// COMPLETE WORKING PROCESSING PROGRAM,
// ILLUSTRATING:
// -- ARRAY OF OBJECTS
// -- MAINTAINING SORTED ORDER OF ARRAY OF OBJECTS
// -- SUBCOLLECTIONS
 
// Global instances of Refrigerator objects:
Refrigerator mainFridge;
Refrigerator miniFridge;
 
 
void setup(){
  size(450, 400);
 
  // Create the instance of the main Refrigerator object.
  // The mini Refrigerator is null for now.
  // Question for you: where does the miniFridge get created?
  mainFridge = new Refrigerator();
  miniFridge = null;
}
 
void draw(){
  background(180);
 
  // Request the main Refrigerator to draw itself.
  // I have modified the render() method to take location & size.
  mainFridge.render(50,50,150,300);
 
  // Since the mini Refrigerator does not exist at the start
  // of the program, only draw it once it has been created.
  if (miniFridge != null){
    miniFridge.render(250,180,150,170);
  }
 
}
 
int miniFridgeType = 0; // just a little hack
 
void keyPressed(){
  switch(key){
  case 'o':
    mainFridge.openDoor();
    break;
  case 'c':
    mainFridge.closeDoor();
    break;
  case '-':
    mainFridge.removeItem();
    break;
  case '+':
    mainFridge.addItem();
    break;
 
  case 'f':
    // When we press the 'f' key,
    // Create the mini-fridge.
    // For this fridge, we ONLY select those foods of a certain "type"
    // (triangle, circle, square).
    miniFridgeType++;
    miniFridgeType%=3;
    miniFridge = mainFridge.makeSubcollectionRefrigerator (miniFridgeType);
    break;
 
  case 'x':
    // When we press the 'x' key,
    // delete whichever item is mouse-selected (in the main fridge),
    // ans shift the remaining items down one position.
    int indexOfSelectedItem = mainFridge.getIndexOfSelectedItem();
    if (indexOfSelectedItem != -1){
      mainFridge.removeSpecificItem(indexOfSelectedItem);
    }
    break;
 
 
  case 'v':
    // when we press the 'v' key,
    // insert a new FoodItem into the main fridge.
    // This FoodItem is generated with a random tallness,
    // and it will have to be inserted in the correct position
    // in the array (maintaining sorted order!).
    // All inserted FoodItems are RED, so you can easily spot them.
    float tallness = 10 + random(35);
    color chroma = color(255,0,0);
    int   type = (int)random(0,3);
    FoodItem F = new FoodItem(tallness, chroma, type);
    mainFridge.insertAndSortNewFoodItem (F);
    break;
  }
}
 
//===============================================
class Refrigerator {
 
  // FIELDS
  int      nFoodItems;
  FoodItem foodItems[];
  boolean  bDoorOpen;
 
  //---------------------------
  // METHODS
 
  Refrigerator(){
    bDoorOpen = false;
    nFoodItems = 0;
 
    int initialFoodItemArraySize = 10;
    foodItems = new FoodItem[initialFoodItemArraySize];
    // ...individual food items will be created (new'd) when they're added.
    // that's one way to do it.
  }
 
  //---------------------------
  void render(int x, int y, int w, int h){
    // IF THE DOOR IS CLOSED, SHOW THE OUTSIDE OF THE FRIDGE.
    if (bDoorOpen == false){
      stroke(0);
      strokeWeight(1);
      fill(255,240,230);
      rect(x,y,w,h);
      fill(180,180,190);
      rect(x+5,y+h/2-40,5,60);
 
      // render silly kid's drawing
      pushMatrix();
      translate(50,50);
      rotate(radians(-15.0));
      translate(x,y);
      fill(255);
      rect(0,0,36,36);
      smooth();
      ellipse(18,18,27,27);
      arc(18,18,20,20, radians(45),radians(135));
      ellipse(12,14,6,6);
      ellipse(24,14,6,6);
      popMatrix();
 
    }
    else {
      // BUT IF THE DOOR IS OPEN, SHOW THE STUFF INSIDE.
      stroke(0);
      strokeWeight(1);
 
      // Draw the fridge enclosure
      fill(200,200,208);
      rect(x,y,w,h);
      fill(240,240,255);
      rect(x+5,y+5,w-10,h-10);
 
      // draw the food items at specified locations.
      // Compute some positions to cleverly position things.
      for (int i=0; i<nFoodItems; i++){
        float foodx = x + 25 + (i%6)*20;
        float foody = y + h - 10 - (60*(i/6));
        foodItems[i].draw(foodx,foody);
      }
    }
  }
 
  //---------------------------
  // ACCESSOR METHODS
  boolean isDoorOpen(){
    return bDoorOpen;
  }
 
  int getNFoodItems(){
    return nFoodItems;
  }
 
  // SIMPLE MUTATOR METHODS
  void closeDoor(){
    bDoorOpen = false;
  }
 
  void openDoor(){
    bDoorOpen = true;
  }
 
  //---------------------------
  Refrigerator makeSubcollectionRefrigerator (int subselectionFoodType){
    // Here, we ask this Refrigerator to create
    // a "subcollection" Refrigerator (such as a cooler or mini-fridge).
 
    // We know (from its signature) that this method *must*
    // return a Refrigerator. So declare and create this right away!
    // And don't forget to return it at the end of the method.
    Refrigerator outputFridge = new Refrigerator();
 
    // Open its door so we can add food to it (ha!)
    outputFridge.openDoor();
 
    // Search through my foodItems array for items which meet the criterion.
    // Add those items to the outputFridge.
    // (Note that "criterion" in this case means, subselectionFoodType.
    // But the criterion could be measuring a continuous property instead --
    // For example, find me all FoodItems taller than.... etc.)
    for (int i=0; i<nFoodItems; i++){
      if (foodItems[i].getType() == subselectionFoodType){
        outputFridge.addItem(foodItems[i]);
      }
    }
 
    // Return the outputFridge.
    return outputFridge;
  }
 
 
  //---------------------------
  // ADDITEM 1: pass in an actual FoodItem object.
  void addItem (FoodItem F){
    if (bDoorOpen){
      foodItems[nFoodItems] = F;
      nFoodItems++;
      if (nFoodItems >= foodItems.length){
        expandFoodItemArray();
      }
    }
    else {
      System.out.println("Door must be open to add an item.");
    }
  }
 
 
  //---------------------------
  // ADDITEM 2: pass in properties for a new FoodItem to be made from
  void addItem (float tallness, color chroma, int type){
    if (bDoorOpen){
      foodItems[nFoodItems] = new FoodItem(tallness, chroma, type);
      nFoodItems++;
      if (nFoodItems >= foodItems.length){
        expandFoodItemArray();
      }
    }
    else {
      System.out.println("Door must be open to add an item.");
    }
  }
 
  //---------------------------
  void addItem(){
    // ADDITEM 3: pass in nothing (no arguments);
    // Adds a randomly-generated item to the end of the array,
    // expanding the array if necessary (if it gets too full).
 
    if (bDoorOpen){
      // If the door is open,
      // generate the properties of a new FoodItem
 
      // This is code for adding a new fooditem to the end.
      // It makes sure that this new food item is 4 pixels taller than
      // what is currently the last item in the array.
      float tallness = 10;
      if (nFoodItems > 0){
        tallness = foodItems[nFoodItems-1].getTallness() + 4.0;
      }
 
      // generate a color and food type for
      // what will be the newly added FoodItem
      color chroma = color(random(100,255), random(128,255), random(0,100));
      int   type = (int)random(0,3);
 
      // .. create and add that FoodItem to the foodItems array.
      foodItems[nFoodItems] = new FoodItem(tallness, chroma, type);
      nFoodItems++;
 
      // Deal with what happens when the user fills up the array.
      // If the number of food items has exceeded the size of the array,
      // Expand the array!
      if (nFoodItems >= foodItems.length){
        expandFoodItemArray();
      }
    }
    else {
      System.out.println("Door must be open to add an item.");
    }
  }
 
  //---------------------------
  void insertAndSortNewFoodItem (FoodItem inputF){
    // Some FoodItem, inputF, is being "inserted" into the array.
    // We are asked to make sure that we maintain "sorted order",
    // in this case, of the "tallness" of the foodItems.
 
    if (bDoorOpen){
      // Only insert new food if the door is open, right?
      // Now fetch the tallness of the inputF FoodItem.
      // Note the use of the accessor method.
      float tallnessOfInputF = inputF.getTallness();
 
      // Search for the index at which to insert this foodItem,
      // to maintain the sorted order of the foodItem array.
      // This could also be accomplished with a while{} loop.
      int indexAtWhichToInsertInputF = 0;
      for (int i=0; i<nFoodItems; i++){
        if (foodItems[i].getTallness() < tallnessOfInputF){
          indexAtWhichToInsertInputF++;
        }
      }
 
      // It's possible we might need to enlarge the size of the array.
      if (nFoodItems >= foodItems.length){
        expandFoodItemArray();
      }
 
      // Shift all elements taller than inputF,
      // one position further down the array.
      for (int i=nFoodItems; i>indexAtWhichToInsertInputF; i--){
        foodItems[i] = foodItems[i-1];
      }
 
      // Insert the inputF. Note how simple this is.
      // Then, don't forget to increase the nFoodItems!
      foodItems[indexAtWhichToInsertInputF] = inputF;
      nFoodItems++;
 
    }
    else {
      System.out.println("Door must be open to insert an item.");
    }
  }
 
 
  //---------------------------
  void removeItem(){
    if (bDoorOpen){
      if (nFoodItems > 0){
        nFoodItems--;
      }
    }
    else {
      System.out.println("Door must be open to remove an item");
    }
  }
 
  //---------------------------
  void removeSpecificItem (int indexFromWhichToRemoveFoodItem){
    // To remove a specific item from the foodItems array,
    // copy all higher-numbered FoodItems down one position in the array.
    if ((indexFromWhichToRemoveFoodItem >= 0) &&
        (indexFromWhichToRemoveFoodItem < nFoodItems)){
      for (int i=indexFromWhichToRemoveFoodItem; i<nFoodItems; i++){
        foodItems[i] = foodItems[i+1];
      }
      nFoodItems--;
    }
  }
 
  //---------------------------
  int getIndexOfSelectedItem(){
    // Loop over all of my FoodItems,
    // and return the array-index of whichever one
    // reports that the mouse is hovering over it.
    int output = -1;
    for (int i=0; i<nFoodItems; i++){
      if (foodItems[i].isMouseHovering()){
        output = i;
      }
    }
    return output;
  }
 
  //---------------------------
  void expandFoodItemArray(){
    // Make a new array ("biggerArray") which
    // holds twice as much stuff as foodItems.
    FoodItem biggerArray[] = new FoodItem[ foodItems.length * 2];
 
    // Copy all of our FoodItems into that bigger array.
    for (int i=0; i<foodItems.length; i++){
      biggerArray[i] = foodItems[i];
    }
 
    // Re-assign foodItems to be that bigger array.
    foodItems = biggerArray;
  }
 
} // End of Refrigerator Class.
 
 
 
 
//=====================================================
//=====================================================
class FoodItem {
 
  float posx, posy;
  float tallness;
  color chroma;
  int   type;
 
  //-----------------------------------
  // Constructor for a FoodItem.
  // All necessary variables are passed in.
  FoodItem (float tallness, color chroma, int type){
    this.tallness = tallness;
    this.chroma   = chroma;
    this.type     = type;
  }
 
  //-----------------------------------
  // How a FoodItem should draw itself.
  // Note that a position is passed in.
  void draw (float x, float y){
    posx = x;
    posy = y;
 
    smooth();
    stroke(0);
    if (isMouseHovering()){
      strokeWeight(4);
    }
    else {
      strokeWeight(1);
    }
 
    fill(chroma);
    switch(type){
    case 0: // RECT
      rect(posx-6,posy-tallness, 12,tallness);
      break;
    case 1: // ELLIPSE
      ellipse(posx,posy-tallness/2, 12,tallness);
      break;
    case 2: // TRIANGLE
      triangle(posx-6,posy, posx+6,posy, posx,posy-tallness);
      break;
    }
    noSmooth();
  }
 
  //-----------------------------------
  // ACCESSOR METHODS.
 
  int getType(){
    return type;
  }
 
  float getTallness(){
    return tallness;
  }
 
  boolean isMouseHovering(){
    return (
    (  mouseX > posx-6) &&
      (mouseX < posx+6) &&
      (mouseY < posy) &&
      (mouseY > posy-tallness));
  }
 
} // End of FoodItem Class.

 
void setup(){
  Thing T1 = new Thing(1);
  Thing T2 = T1.getBiggerThing();
  Thing T2prime = T2.getVerySimilarThing();
 
 
  Thing T1duplicate = new Thing(T1);
  println("The property of T1duplicate = " + T1duplicate.property);
}
 
 
class Thing {
  int property;
 
  //constructor
  Thing (int p){
    property = p;
  }
 
  //copy constructor
  Thing (Thing originalThing){
    this.property = originalThing.property;
  }
 
  // factory method
  Thing getVerySimilarThing(){
    return new Thing(property);
  }
 
  // factory method
  Thing getBiggerThing(){
    return new Thing(property+1);
  }
}