import ioio.lib.util.*;
import ioio.lib.impl.*;
import ioio.lib.api.*;
import ioio.lib.api.exception.*;

/* This is our thread class, it's a subclass of the standard thread class that comes with Processing
 * we're not really doing anything dramatic, just using the start and run methods to control our interactions with the IOIO board
 */
 
class myIOIOThread extends Thread {
 
  boolean running;  //is our thread running?
  String id; //in case we want to name our thread
  int wait; //how often our thread should run
  DigitalOutput led;  //DigitalOutput type for the onboard led
  int count; //if we wanted our thread to timeout, we could put a counter on it, I don't use it in this sketch
 
  //our constructor
  myIOIOThread(String s, int w) {
 
    id = s;
    wait = w;
    running = false;
    count = 0;
  }
 
  //override the start method
  void start() {
    running = true;
 
    //try connecting to the IOIO board, handle the case where we cannot or the connection is lost
    try {
      IOIOConnect();  //this function is down below and not part of the IOIO library
    }
    catch (ConnectionLostException e) {
    }
 
    //try setting our led pin to the onboard led, which has a constant 'LED_PIN' associated with it
    try {
      led = ioio.openDigitalOutput(IOIO.LED_PIN);
    }
    catch (ConnectionLostException e) {
    }
 
    //don't forget this
    super.start();
  }
 
  //start automatically calls run for you
  void run() {
 
    //while our sketch is running, keep track of the lightOn boolean, and turn on or off the led accordingly
    while (running) {
      //count++;
 
      //again, we have to catch a bad connection exception
      try {
        led.write(lightOn);
      }
      catch (ConnectionLostException e) {
      }
 
      try {
        sleep((long)(wait));
      }
      catch (Exception e) {
      }
    }
  }
 
 //often we may want to quit or stop or thread, so I include this here but I'm not using it in this sketch
  void quit() {
    running = false;
    ioio.disconnect();
    interrupt();
  }
 
//a simple little method to try connecting to the IOIO board
  void IOIOConnect() throws ConnectionLostException {
 
    try {
      ioio.waitForConnect();
    }
    catch (IncompatibilityException e) {
    }
  }
}

/* IOIO Test 4 -
 * Toggling a real LED on pin 3, and reading values from a potentiometer on pin 37 through Processing in Android mode
 * by Ben Leduc-Mills
 * This code is Beerware - feel free to reuse and credit me, and if it helped you out and we meet someday, buy me a beer.
 */
 
import apwidgets.*;
 
import ioio.lib.util.*;
import ioio.lib.impl.*;
import ioio.lib.api.*;
import ioio.lib.api.exception.*;
 
APWidgetContainer widgetContainer;
APButton button1;
int rectSize = 100;
boolean lightOn = false;
 
IOIO ioio = IOIOFactory.create();
myIOIOThread thread1; 
 
void setup() {
  thread1 = new myIOIOThread("thread1", 100);
  thread1.start();
 
  size(480, 800);
  smooth();
  noStroke();
  fill(255);
  rectMode(CENTER);     //This sets all rectangles to draw from the center point
 
  widgetContainer = new APWidgetContainer(this);
  button1 = new APButton(10, 10, "Toggle LED");
  widgetContainer.addWidget(button1); //place button in container
}
 
void draw() {
  background(#FF9900);
  //change the fill value based on the analog read of our potentiometer
  fill(thread1.value * 100); //it's * 100 because we only get values from 0-1, so really this should be * 255, or use the map function
  rect(width/2, height/2, rectSize, rectSize);
}
 
//onClickWidget is called when a widget is clicked/touched
void onClickWidget(APWidget widget) {
 
  if (widget == button1) { //if it was button1 that was clicked
 
    if (lightOn == true) {
      lightOn = false;
      rectSize = 50;
    }
    else if (lightOn == false) {
      lightOn = true;
      rectSize = 100;
    }
  }
}

class myIOIOThread extends Thread {
 
  boolean running;
  String id;
  int wait;
  DigitalOutput led;
  AnalogInput in;
  int count;
  int ledpin = 3; //pin for our led
  int potpin = 37; // pin for our potentiometer
  float value; //our analog values range from 0 to 1
 
  myIOIOThread(String s, int w) {
 
    id = s;
    wait = w;
    running = false;
    count = 0;
 
  }
 
  void start() {
    running = true;
 
    try {
      IOIOConnect();
    }
    catch (ConnectionLostException e) {
    }
 
    try {
 
      led = ioio.openDigitalOutput(ledpin);
      in = ioio.openAnalogInput(potpin);
    }
    catch (ConnectionLostException e) {
    }
 
    super.start();
  }
 
  void run() {
 
    while (running) {
      //count++;
      try {
        led.write(lightOn);
        value = in.read();
      }
      catch (ConnectionLostException e) {
      }
      catch (InterruptedException e) {
      }
 
      try {
        sleep((long)(wait));
      }
      catch (Exception e) {
      }
    }
  }
 
  void quit() {
    running = false;
    //led.close();
    ioio.disconnect();
    interrupt();
  }
 
  void IOIOConnect() throws ConnectionLostException {
 
    try {
      ioio.waitForConnect();
    }
    catch (IncompatibilityException e) {
    }
  }
}

/*
 * Danger Shield VJDJ
 * Using the Danger Shield from SparkFun to do live Video and Audio manipulation
 * by Ben Leduc-Mills - https://benatwork.cc
 * video code based off code by Dan Shiffman - http://shiffman.net
 * This code is public domain but you buy me a beer if you use this and we meet someday (Beerware license)
 */
 
import processing.core.PApplet;
import processing.serial.Serial;
import processing.video.*;
import ddf.minim.*;
 
public class DangerShieldAV extends PApplet {
 
	Capture myCamera;
	MovieMaker mm;
 
	Minim minim;
	AudioSample kick;
	AudioSample snare;
 
	Serial usbPort;
	// Size of each cell in the grid
	int cellSize = 20;
	// Number of columns and rows in our system
	int cols, rows;
	//int[] sensors;
	String[] sensors;
	boolean firstContact = false;
 
	int slider1, slider2, slider3;
	int button1, button2, button3;
	int photoCell;
 
	public void setup() {
		size(800,600);
 
		minim = new Minim(this);
		kick = minim.loadSample("kick.wav", 2048);
		snare = minim.loadSample("snare.wav", 2048);
 
		myCamera = new Capture(this, width, height, 15);
		mm = new MovieMaker(this, width, height, "drawing.mov");
		cols = width / cellSize;
		rows = height / cellSize;
		colorMode(RGB, 255, 255, 255, 100);
 
		usbPort = new Serial (this, Serial.list( )[0], 9600);
		usbPort.bufferUntil ('\n');
		background(0);
	}
 
	public void draw() {
 
		doSounds();
 
		if (myCamera.available()) {
			myCamera.read();
			myCamera.loadPixels();
 
			// Begin loop for columns
			for (int i = 0; i < cols; i++) {
				// Begin loop for rows
				for (int j = 0; j < rows; j++) {
 
					int x = i*cellSize;
					int y = j*cellSize;
					int loc = (myCamera.width - x - 1) + y*myCamera.width; // Reversing x to mirror the image
 
					float r = red(myCamera.pixels[loc]);
					float g = green(myCamera.pixels[loc]);
					float b = blue(myCamera.pixels[loc]);
					// Make a new color with an alpha component
					int c = color(r, g, b, 55);
 
					// Code for drawing a single rect
					// Using translate in order for rotation to work properly
					pushMatrix();
					translate(x+cellSize/2, y+cellSize/2);
 
					// Rotation formula based on slider1 value
					rotate((float) (2 * PI * brightness(c) / slider1));
					rectMode(CENTER);
 
					fill(c);
					noStroke();
					// Width and height of rects are based on slider2 and slider3 values
					rect(0, 0, slider2/4, slider3/4);
					popMatrix();
				}
			}
		}
 
		mm.addFrame();
	}
 
	public void doSounds() {
 
		//if button1 is pressed, play kick sound
		if(button1 == 0) {
 
			kick.trigger();
 
		}
 
		//if button2 is pressed, play snare sound
		if(button2 == 0) {
 
			snare.trigger();
		}
	}
 
	public void keyPressed() {
		  if (key == ' ') {
		    // Finish the movie if space bar is pressed
		    mm.finish();
		    // Quit running the sketch once the file is written
		    exit();
		  }
		}
 
	public void stop()
	{
	  // always close Minim audio classes when you are done with them
	  kick.close();
	  snare.close();
	  minim.stop();
 
	  super.stop();
	}
 
	public void serialEvent ( Serial usbPort ) {
		String usbString = usbPort.readStringUntil ('\n');
		if (usbString != null) {
			usbString = trim(usbString);
 
			//serial handshake
			if (firstContact == false) {
				if (usbString.equals("Hello")) {
					usbPort.clear();
					firstContact = true;
					usbPort.write('A');
					println("contact");
				}
			}
			else {
 
				//we got something, put the sensor values in their own variables
				sensors = split(usbString, ',');
				for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
				}
 
				slider1 = Integer.parseInt(sensors[0]);
				button1 = Integer.parseInt(sensors[1]);
				slider2 = Integer.parseInt(sensors[2]);
				button2 = Integer.parseInt(sensors[3]);
				slider3 = Integer.parseInt(sensors[4]);
				button3 = Integer.parseInt(sensors[5]);
				photoCell = Integer.parseInt(sensors[7]);
 
				//request more data!
				usbPort.write("A");
			}
		}
	}
 
}

/* Arduino code for DangerShield VJDJ
 * by Ben Leduc-Mills
 * Released under the beerware licence (if you use it, and we meet, you can buy me a beer)
 */
 
// Pin definitions
#define SLIDER3  0
#define SLIDER2  1
#define SLIDER1  2
 
//#define KNOCK    5
//
//#define CAP1  2
//#define CAP1  9
 
#define BUTTON1  10
#define BUTTON2  11
#define BUTTON3  12
 
#define LED1  5
#define LED2  6
 
#define BUZZER   3
 
#define TEMP  4
 
#define LIGHT  3
 
#define LATCH 7
#define CLOCK 8
#define DATA 4
 
//char START_BYTE = '*';
char DELIMITER = ',';
//char END_BYTE = '#';
int val;
 
// Shift register bit values to display 0-9 on the seven-segment display
const byte ledCharSet[10] = {
 
  B00111111,B00000110,B01011011,B01001111,B01100110,B01101101,B01111101,B00000111,B01111111,B01101111
};
 
void setup()
{
 
  pinMode(BUZZER, OUTPUT);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  digitalWrite(LED1,HIGH);
  digitalWrite(LED2,HIGH);
  pinMode(LATCH, OUTPUT);
  pinMode(CLOCK, OUTPUT);
  pinMode(DATA,OUTPUT);
  digitalWrite(10, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(12, HIGH);
  Serial.begin(9600); 
  establishContact();
}
 
void loop(){
 
  //Serial.print(START_BYTE, BYTE);
 
  val = analogRead(SLIDER1); //read slider1
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = digitalRead(BUTTON1);//read button1
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = analogRead(SLIDER2); //read slider2
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = digitalRead(BUTTON2); //read button2
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = analogRead(SLIDER3); //read slider3
 
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = digitalRead(BUTTON3);//read button3
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  val = analogRead(TEMP);
  Serial.print(val, DEC);
  Serial.print(DELIMITER);  
 
  val = analogRead(LIGHT);
 
  Serial.print(val, DEC);
  Serial.print(DELIMITER);
 
  int sevenSeg = (int)map(val, 400, 900, 1, 9);
  Serial.println(sevenSeg);
 
  digitalWrite(LATCH, LOW);
  shiftOut(DATA, CLOCK, MSBFIRST, ~(ledCharSet[sevenSeg]));
  digitalWrite(LATCH, HIGH);
 
  //Serial.println(END_BYTE, BYTE);
}
 
void establishContact() {
  while (Serial.available() <= 0) {
    Serial.println("Hello");   // send a starting message
    delay(300);
  }
}

/* UCube v.08
 * 3d modeling input device and stl export
 * now using toxiclibs and opengl
 * Manual rotation, shape mode toggle, and export button
 * by Ben Leduc-Mills - 2.10.11
 */
 
import processing.opengl.*;
import newhull.*;
import java.awt.event.*;
import toxi.geom.*;
import toxi.geom.mesh.*;
import toxi.processing.*;
import controlP5.*;
import processing.serial.*;
 
import javax.media.opengl.GL;
 
ControlP5 controlP5;
//Nav3D nav; // camera controller
 
QuickHull3D hull = new QuickHull3D(); //init quickhull
Point3d[] points; //init Point3d array
Point3d[] savedPoints;
 
ToxiclibsSupport gfx;
Mesh3D mesh = new TriangleMesh();
Vec3D[] vectors;
 
Serial myPort; // the serial port
 
float rotX, rotY; //for manual roatation
int gridSize = 4; //size of grid (assumes all dimensions are equal)
int spacing = 50; //distance between points
int counter = 0; //wireframe toggle
String inString; //string of coordinates from arduino
String oldString;
boolean reDraw = true;
PFont myFont; //init font for text
 
PGraphicsOpenGL pgl;
GL gl;
 
void setup() {
 
  size(1400,850,OPENGL);
  frameRate(13);
  gfx=new ToxiclibsSupport(this); // initialize ToxiclibsSupport
  //background(255); 
 
  pgl = (PGraphicsOpenGL) g; //processing graphics object
  gl = pgl.beginGL(); //begin opengl
  gl.setSwapInterval(1); //set vertical sync on
  pgl.endGL(); //end opengl
 
  controlP5 = new ControlP5(this);
  controlP5.addButton("Mode", 0,100,120,80,19);
  controlP5.addButton("Export", 0,100,140,80,19);
 
  myFont = createFont("FFScala", 32);
  textFont(myFont);
 
  println(Serial.list()); // list available serial ports
  myPort = new Serial(this, Serial.list()[0], 19200);
  myPort.bufferUntil('\n');
 
} 
 
void draw() {
 
  //}
 
  //void serialEvent(Serial myPort) {
 
  if (myPort.available() > 0) {
  background(255);
  smooth();
  // because we want controlP5 to be drawn on top of everything
  // else we need to disable OpenGL's depth testing at the end
  // of draw(). that means we need to turn it on again here.
  hint(ENABLE_DEPTH_TEST);
 
  pushMatrix();
  //lights();
  translations();
  drawGrid();
  drawAxes();
 
  String inString = myPort.readStringUntil('\n');
  //String m1[] = match(inString, "[0-3]");
 
  //TODO: compare inString to oldString to see if coords changed
 
  //if a coordinate string is coming in from arduino
  if (inString != null) {
    //make acive points more visible
    strokeWeight(8);
    stroke(255, 0, 0); 
 
    if (inString != oldString) {
      reDraw = true;
      oldString = inString;
    }
 
    inString = trim(inString);
    //split string of mutliple coordinates into coordinate-sized chuncks
    String coord[] = split(inString, ';');
 
    //init point3d array equal to number of activated points
    points = new Point3d[coord.length-1]; 
 
    //put the xyz coordinates into the point3d array and draw them
    for(int p3d = 0; p3d < coord.length-1; p3d++) {
 
      int subCoord[] = int(split(coord[p3d], ','));
      points[p3d] = new Point3d(subCoord[0] * spacing, subCoord[1] * spacing, subCoord[2] * spacing);
      point(subCoord[0] * spacing, subCoord[1] * spacing, subCoord[2] * spacing );
    }
 
    if (counter%2 != 0) {
      drawHull();
    }
  } //end if inString!=null
  popMatrix();
  // turn off depth test so the controlP5 GUI draws correctly
  hint(DISABLE_DEPTH_TEST);
  }
}
 
public void controlEvent(ControlEvent theEvent) {
  println(theEvent.controller().name());
}
 
void mouseDragged() {
  float x1 = mouseX-pmouseX;
  float y1 = mouseY-pmouseY;
  rotX = (mouseY * -0.01);
  rotY = (mouseX * 0.01);
}
 
void translations() {
  translate(width/2, height/2);
  rotateX(rotX);
  rotateY(rotY);
}
 
void drawGrid() {
 
  //draw rest of grid
  //(spacing * (gridSize -1) * -1) /2 = center around 0
  int xpos = 0;
  int ypos = 0;
  int zpos = 0;
 
  for (int i = 0; i < gridSize; i++) {
    for (int j = 0; j < gridSize; j++) {
      for( int k = 0; k < gridSize; k++) {
        stroke(100);
        strokeWeight(2);
        point(xpos, ypos, zpos);
        //println(xpos + "," + ypos + "," + zpos);
        xpos += spacing;
      }
      xpos = 0;
      ypos += spacing;
    }
    xpos = 0;
    ypos = 0;
    zpos += spacing;
  }
}
 
void drawAxes() {
 
  stroke(255,0,255);
  line(0,0,0, 100,0,0);
  fill(255,0,255);
  text("X", 200, 0);
  stroke(0,255,0);
  line(0,0,0, 0,-100,0);
  fill(0,255,0);
  text("Y", 0, -200);
  stroke(0,0,255);
  line(0,0,0, 0,0,100);
  fill(0,0, 255);
  text("Z", 0, 0, 200);
  fill(0,0,0);
}
 
public void Mode(int theValue) {
  counter++;
  println(counter);
  drawHull();
}
 
public void Export(int theValue) {
  outputSTL();
}
 
void outputSTL() {
 
  TriangleMesh mySTL = new TriangleMesh();
 
  for(int i = 0; i < vectors.length; i+=3) {
 
    mesh.addFace(vectors[i], vectors[i+1], vectors[i+2]);
   // println(vectors[i] + " " + vectors[i+1] + " " + vectors[i+2]);
  }
 
  mySTL.addMesh(mesh);
  mySTL.saveAsSTL(selectOutput());
}
 
void drawHull() {
 
  int numPoints = points.length;
  //check that our hull is valid
 
  if(hull.myCheck(points, numPoints) == false) {
 
    //brute force inefficiency
    beginShape(TRIANGLE_STRIP);
    strokeWeight(1);
    fill(0);
 
    for (int j = 0; j < numPoints; j++) {
 
      float x = (float)points[j].x;
      float y = (float)points[j].y;
      float z = (float)points[j].z;
      vertex(x,y,z);
    }
 
    endShape(CLOSE);
  }
 
  else if (hull.myCheck(points, numPoints) == true) {  
 
    if(reDraw == true) {
      //print("redraw = true");
      hull.build(points);
      hull.triangulate();
      //get an array of the vertices so we can get the faces
      Point3d[] vertices = hull.getVertices();
      savedPoints = new Point3d[0];
      vectors = new Vec3D[0];
 
      beginShape(TRIANGLE_STRIP);
      strokeWeight(1);
      //noFill();
      int[][] faceIndices = hull.getFaces();
      for (int i = 0; i < faceIndices.length; i++) {
        for (int k = 0; k < faceIndices[i].length; k++) {
 
          //get points that correspond to each face
          Point3d pnt2 = vertices[faceIndices[i][k]];
          float x = (float)pnt2.x;
          float y = (float)pnt2.y;
          float z = (float)pnt2.z;
          vertex(x,y,z);
          Vec3D tempVect = new Vec3D(x,y,z);
          //println(x + "," + y + "," + z + " " + k);
          savedPoints = (Point3d[])append(savedPoints, pnt2);
          vectors = (Vec3D[])append(vectors, tempVect);
          //savedPoints[k] = new Point3d(pnt2);
          //println(savedPoints[k]);
 
          //println(x + "," + y + "," + z);
        }
      }
      endShape(CLOSE);
      reDraw = false;
    }
 
    else if(reDraw == false) {
      // print("redraw = false");
      beginShape(TRIANGLE_STRIP);
      strokeWeight(1);
      //noFill();
      for(int i = 0; i < savedPoints.length; i++) {
 
        float x = (float)savedPoints[i].x;
        float y = (float)savedPoints[i].y;
        float z = (float)savedPoints[i].z;
        vertex(x,y,z);
      }
      endShape(CLOSE);
    }
  }
}