Voyeurism Redux

//Kim Ash
//Voyeur 2
//CompCams Spring 2012
import processing.core.PApplet;
import java.awt.Dimension;
import java.awt.Image;
import java.awt.image.BufferedImage;
import java.awt.image.PixelGrabber;
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.net.HttpURLConnection;
import java.net.URL;
import processing.core.PApplet;
import processing.core.PImage;
import javax.imageio.ImageIO;
 
public class Voyeur extends PApplet {
	//.28 Phys Comp (406)
	//.29 inactive - can go in ex-res when needed
	//.188 ("Is Our Machines Learning")
	//.189 On your desk...
 
	//Capture video; 
	//this is what you use for ordinary video cameras
	//requires pointing at the video.jar library from processing
 
	CaptureAxisCamera video;	 //This acts the same the regular but connects to axis net cam
	CaptureAxisCamera video2;
 
	BlurBox box1;
	BlurBox box2;
 
	static public void main(String _args[]) {
		PApplet.main(new String[] { "Voyeur" });
	}
 
	public void setup() {
 
		size(1290,550);
		video = new CaptureAxisCamera(this, "195.43.56.144",width,height,true);	//bar in Engelberg, Switzerland
		video2 = new CaptureAxisCamera(this, "oviso.axiscam.net",width,height,true);	//bar in Barcelona, Spain
		box1 = new BlurBox(500, height/2, 100, 200);
		box2 = new BlurBox(650, height/2, 200, 100);
		//video = new Capture(this, 640,480);
		//this is what you use for ordinary video cameras
	}
 
	public void draw() {
		if (video.available()) {
			video.read();
			image(video, 0, 0);
			//println(video.mjpgURL);
		}
 
		if (video2.available()) {
			video2.read();
			image(video2, 650, 15);
			//println(video3.mjpgURL);
		}
 
		box1.display();
	    box1.drag(mouseX, mouseY);
 
	    box2.display();
	    box2.drag(mouseX, mouseY);
 
		/*fill(255, 0, 0);
		textSize(20);
		text("Engelberg, Switzerland", 10, 270);
		text("Barcelona, Spain", 660, 510);*/
 
	}
 
public class BlurBox {
	int x, y, w, h;
	  boolean dragging = false; // Is the object being dragged?
	  int offsetX, offsetY; // Mouseclick offset
	  PImage blurred;
 
	  BlurBox (int x_, int y_, int w_, int h_) {
	    x = x_;
	    y = y_;
	    w = w_;
	    h = h_;
	    offsetX = 0;
	    offsetY = 0;
	    blurred = new PImage(w_, h_);
	  }
 
	  void display() {
	    // pushMatrix(); you shouldn't need this
	    if (dragging) stroke(255, 255, 0);
	    else stroke(0, 255, 0);
 
	    //fill(0, 0, 0, 150);
	    noFill();
	    //filter(BLUR, 6);
 
	    blurred = get(x, y, w, h);
	    blurred.filter(BLUR, 5);
	    image(blurred, x, y);
 
	    rect(x, y, w, h);
 
	    //  popMatrix(); you shouldn't need this either
	  }
 
 
	  // Is a point inside the rectangle (for click)?
	  boolean clicked(int mx, int my) {
	    if (mx > x && mx < x + w && my > y && my < y + h) {
	      dragging = true;
	      // If so, keep track of relative location of click to corner of rectangle
	      offsetX = x-mx;
	      offsetY = y-my;
	      return true;
	    }
	    else return false;
	  }
 
	  // Is a point inside the rectangle (for rollover)
	  /*void rollover(int mx, int my) {
	   if (mx > x && mx < x + w && my > y && my < y + h) {
	   rollover = true;
	   } else {
	   rollover = false;
	   }
	   }*/
 
	  // Stop dragging
	  void stopDragging() {
	    dragging = false;
	  }
 
	  // Drag the rectangle
	  void drag(int mx, int my) {
	    if (dragging) {
	      x = mx + offsetX;
	      y = my + offsetY;
	    }
	  }
}
 
public void mousePressed() {
	  box1.clicked(mouseX,mouseY);
	  box2.clicked(mouseX,mouseY);
	}
 
public void mouseReleased() {
	  box1.stopDragging();
	  box2.stopDragging();
	}
/**
 * 
 * @author David E. Mireles, Ph.D. (adapted for processing by Dan O'Sullivan)
 */
public class CaptureAxisCamera extends PImage implements Runnable {
	public boolean useMJPGStream = false;
 
	public String ip = "";
	public String jpgURL = "http://128.122.151.200/axis-cgi/jpg/image.cgi?resolution=352x240";
 
	public String mjpgURL  = "http://128.122.151.189/axis-cgi/mjpg/video.cgi?resolution=352x240";
 
	DataInputStream dis;
 
    Image image;
 
    BufferedImage bimage;
 
	public Dimension imageSize = null;
 
	public boolean connected = false;
 
	private boolean initCompleted = false;
 
	HttpURLConnection huc = null;
 
	PApplet parent;
 
	boolean crop;
 
	boolean available;
 
	Method captureEventMethod;
 
	/** Creates a new instance of AxisCamera */
	public CaptureAxisCamera(PApplet _parent, String _ip,int _w, int _h, boolean _useMJPGStream) {
		ip = _ip;
		parent = _parent;
		useMJPGStream = _useMJPGStream;
		jpgURL = "http://"+ ip + "/axis-cgi/jpg/image.cgi?resolution="+ String.valueOf(_w)+ "x" +String.valueOf(_h);
 
		//jpgURL = "";
		mjpgURL  = "http://"+ ip +"/axis-cgi/mjpg/video.cgi?resolution="+ String.valueOf(_w)+ "x" +String.valueOf(_h);
 
		// initialize my PImage self
		super.init(_w, _h, RGB);
 
 
 
 
		try {
			captureEventMethod = parent.getClass().getMethod("captureEvent", new Class[] { CaptureAxisCamera.class });
		} catch (Exception e) {
			// no such method, or an error.. which is fine, just ignore
		}
 
 
 
		Thread myThread = new Thread(this);
		myThread.start();
 
		parent.registerDispose(this);
	}
 
	/**
	 * True if a frame is ready to be read.
	 * 
	 * // put this somewhere inside draw if (capture.available()) capture.read();
	 * 
	 * 
	 * 
	 * Alternatively, you can use captureEvent(Capture c) to notify you whenever available() is set to true. In which case, things might look like this:
	 * 
	 * 
	 * 
	 * public void captureEvent(Capture c) { c.read(); // do something exciting now that c has been updated }
	 * 
	 * 
	 */
	public boolean available() {
		return available;
	}
 
	public void read() {
		// try {
		// synchronized (capture) {
		if (image != null){
		loadPixels();
		synchronized (pixels) {
			// System.out.println("read1");
			if (crop) {
				// System.out.println("read2a");
				// f#$)(#$ing quicktime / jni is so g-d slow, calling copyToArray
				// for the invidual rows is literally 100x slower. instead, first
				// copy the entire buffer to a separate array (i didn't need that
				// memory anyway), and do an arraycopy for each row.
				/*
				 * if (data == null) { data = new int[dataWidth * dataHeight]; } raw.copyToArray(0, data, 0, dataWidth * dataHeight); int sourceOffset = cropX + cropY * dataWidth; int destOffset = 0; for (int y = 0; y < cropH; y++) { System.arraycopy(data, sourceOffset, pixels, destOffset, cropW); sourceOffset += dataWidth; destOffset += width; }
				 */
			} else { // no crop, just copy directly
				// System.out.println("read2b");
				// theData = (byte[]) imageBuffer.getData();
 
				PixelGrabber pg = new PixelGrabber(image,0,0,width,height,pixels,0,width);
 
				   try {
					      pg.grabPixels();
					    } catch (InterruptedException e) { }
				// raw.copyToArray(0, pixels, 0, width * height);
			// }
			// System.out.println("read3");
					    }
			available = false;
			// mark this image as modified so that PGraphicsJava2D and
			// PGraphicsOpenGL will properly re-blit and draw this guy
			updatePixels();
			// System.out.println("read4");
		}
		}
	}
	public void connect() {
		try {
			URL u = new URL(useMJPGStream ? mjpgURL : jpgURL);
			huc = (HttpURLConnection) u.openConnection();
			// System.out.println(huc.getContentType());
			InputStream is = huc.getInputStream();
			connected = true;
			BufferedInputStream bis = new BufferedInputStream(is);
			dis = new DataInputStream(bis);
			if (!initCompleted) initDisplay();
		} catch (IOException e) { // in case no connection exists wait and try again, instead of printing the error
			try {
				huc.disconnect();
				Thread.sleep(60);
			} catch (InterruptedException ie) {
				huc.disconnect();
				connect();
			}
			connect();
		} catch (Exception e) {
			;
		}
	}
 
	public void initDisplay() { // setup the display
		if (useMJPGStream)
			readMJPGStream();
		else {
			readJPG();
			disconnect();
		}
		initCompleted = true;
	}
 
	public void disconnect() {
		try {
			if (connected) {
				dis.close();
				connected = false;
			}
		} catch (Exception e) {
			;
		}
	}
 
 
	public void readStream() { // the basic method to continuously read the stream
		try {
			if (useMJPGStream) {
				while (true) {
					readMJPGStream();
 
				}
			} else {
				while (true) {
					connect();
					readJPG();
 
					disconnect();
 
				}
			}
 
		} catch (Exception e) {
			;
		}
	}
 
	public void readMJPGStream() { // preprocess the mjpg stream to remove the mjpg encapsulation
		readLine(3, dis); // discard the first 3 lines
		readJPG();
		readLine(2, dis); // discard the last two lines
	}
	public BufferedImage getImage(){
		available = false;
		return bimage;
	}
	public void readJPG() { // read the embedded jpeg image
		try {			
			bimage = ImageIO.read(dis);
			image = bimage;
			available = true;
			if (captureEventMethod != null) {
				try {
					captureEventMethod.invoke(parent, new Object[] { this });
				} catch (Exception e) {
					System.err.println("Disabling captureEvent()  because of an error.");
					e.printStackTrace();
					captureEventMethod = null;
				}
			}
 
		} catch (Exception e) {
			e.printStackTrace();
			disconnect();
		}
	}
	/**
	 * Called by PApplet to shut down video so that QuickTime can be used later by another applet.
	 */
	public void dispose() {
		disconnect();
 
	}
	public void readLine(int n, DataInputStream dis) { // used to strip out the header lines
		for (int i = 0; i < n; i++) {
			readLine(dis);
		}
	}
 
	public void readLine(DataInputStream dis) {
		try {
			boolean end = false;
			String lineEnd = "n"; // assumes that the end of the line is marked with this
			byte[] lineEndBytes = lineEnd.getBytes();
			byte[] byteBuf = new byte[lineEndBytes.length];
 
			while (!end) {
				dis.read(byteBuf, 0, lineEndBytes.length);
				String t = new String(byteBuf);
				// System.out.print(t); //uncomment if you want to see what the lines actually look like
				if (t.equals(lineEnd)) end = true;
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
 
	}
 
	public void run() {
		connect();
		readStream();
	}
}
}