Community Core Vision

     	ccv = new ofxNCoreVision;
+    }
     //--------------------------------------------------------------
     void testApp::update()
+    {
+    }
     void testApp::update(){}
     //--------------------------------------------------------------
     void testApp::draw()
-...
+    }
     //--------------------------------------------------------------
     void testApp::keyPressed  (int key)
+    {
+    }
     void testApp::keyPressed  (int key){}
     //--------------------------------------------------------------
     void testApp::keyReleased  (int key)
+    {
+    }
     void testApp::keyReleased  (int key){}
     //--------------------------------------------------------------
     void testApp::mouseMoved(int x, int y )
+    {
+    }
     void testApp::mouseMoved(int x, int y ){}
     //--------------------------------------------------------------
     void testApp::mouseDragged(int x, int y, int button)
+    {
+    }
     void testApp::mouseDragged(int x, int y, int button){}
     //--------------------------------------------------------------
     void testApp::mousePressed(int x, int y, int button)
+    {
+    }
     void testApp::mousePressed(int x, int y, int button){}
     //--------------------------------------------------------------
     void testApp::mouseReleased()
+    {
+    }
     void testApp::mouseReleased(){}
     /*****************************************************************************
      *	TOUCH EVENTS
      *****************************************************************************/
     void testApp::TouchDown( Blob b)
+    {
+    }
     void testApp::TouchDown(Blob b){}
     void testApp::TouchUp( Blob b)
+    {
+    }
     void testApp::TouchUp(Blob b){}
     void testApp::TouchMoved( Blob b)
+    {
+    }
     void testApp::TouchMoved( Blob b){}

         ///////////////////////////////////////////// -->
         <!--// CAMERA SETTINGS // -->
         <CAMERA_0>
             <USECAMERA>0</USECAMERA>
             <USECAMERA>1</USECAMERA>
             <DEVICE>0</DEVICE>
             <WIDTH>320</WIDTH>
             <HEIGHT>240</HEIGHT>
-...
         <NETWORK>
             <LOCALHOST>127.0.0.1</LOCALHOST>
             <TUIO>0</TUIO>
             <TUIOPORT_OUT>7000</TUIOPORT_OUT>
             <TUIOPORT_OUT>3333</TUIOPORT_OUT>
             <TUIOFLASHPORT_OUT>3000</TUIOFLASHPORT_OUT>
         </NETWORK>
         <!--// VIDEO SETTINGS // -->
-...
             <LABELS>1</LABELS>
             <OUTLINES>1</OUTLINES>
             <LEARNBG>0</LEARNBG>
             <TUIO>0</TUIO>
             <TUIO>1</TUIO>
             <VMIRROR>0</VMIRROR>
             <HMIRROR>0</HMIRROR>
             <HIGHPASS>1</HIGHPASS>
             <AMPLIFY>1</AMPLIFY>
             <SMOOTH>1</SMOOTH>
             <SMOOTH>0</SMOOTH>
             <GPU>0</GPU>
             <DYNAMICBG>0</DYNAMICBG>
             <SNAPSHOT>0</SNAPSHOT>
             <MINIMODE>1</MINIMODE>
             <MINIMODE>0</MINIMODE>
             <HEIGHTWIDTH>0</HEIGHTWIDTH>
             <OSCMODE>0</OSCMODE>
             <OSCMODE>1</OSCMODE>
             <TCPMODE>0</TCPMODE>
             <TRACKDARK>0</TRACKDARK>
         </BOOLEAN>
         <INT>
             <MINMOVEMENT>0</MINMOVEMENT>
             <MINBLOBSIZE>1</MINBLOBSIZE>
             <MAXBLOBSIZE>343</MAXBLOBSIZE>
             <MINMOVEMENT>3</MINMOVEMENT>
             <MINBLOBSIZE>4</MINBLOBSIZE>
             <MAXBLOBSIZE>1000</MAXBLOBSIZE>
             <!--// FILTERS SETTERS //-->
             <THRESHOLD>76</THRESHOLD>
             <HIGHPASSBLUR>58</HIGHPASSBLUR>
             <HIGHPASSNOISE>3</HIGHPASSNOISE>
             <HIGHPASSAMP>35</HIGHPASSAMP>
             <SMOOTH>2</SMOOTH>
             <THRESHOLD>12</THRESHOLD>
             <HIGHPASSBLUR>32</HIGHPASSBLUR>
             <HIGHPASSNOISE>7</HIGHPASSNOISE>
             <HIGHPASSAMP>54</HIGHPASSAMP>
             <SMOOTH>5</SMOOTH>
             <BGLEARNRATE>118.945450</BGLEARNRATE>
         </INT>
     </CONFIG>

             <GRIDY>1</GRIDY>
         </GRIDMESH>
         <BOUNDINGBOX>
             <ulx>0.080000</ulx>
             <uly>0.066000</uly>
             <lrx>0.956001</lrx>
             <lry>0.941001</lry>
             <ulx>0.000000</ulx>
             <uly>0.000000</uly>
             <lrx>1.000000</lrx>
             <lry>1.000000</lry>
         </BOUNDINGBOX>
         <POINT>
             <X>227.000000</X>
             <Y>147.000000</Y>
             <X>129.000000</X>
             <Y>157.000000</Y>
         </POINT>
         <POINT>
             <X>239.000000</X>
             <Y>3.000000</Y>
             <X>207.000000</X>
             <Y>164.000000</Y>
         </POINT>
         <POINT>
             <X>66.000000</X>
             <Y>217.000000</Y>
             <X>113.000000</X>
             <Y>219.000000</Y>
         </POINT>
         <POINT>
             <X>55.000000</X>
             <Y>3.000000</Y>
             <X>203.000000</X>
             <Y>209.000000</Y>
         </POINT>
     </SCREEN>
     <WARP>

branches/tbeta/Windows-PS3EyeMuticam/apps/addonsExamples/VS2008/bin/data/cameras.xml (revision 198)
50	50	<section name="stitching">
51	51	<subsection name="cameras">
52	52	<item name="position" value="1" />
53		<item name="overlap" value="27" />
	53	<item name="overlap" value="207" />
54	54	</subsection>
55	55	</section>

     void ofxPS3::listDevices()
+    {
     	// Enumerate the cameras on the USB bus
     	// Enumerate the cameras on the bus.
     	camNum = PS3EyeMulticamGetCameraCount();
      	printf("\nFound %d PS3Eye camera(s)...\n", camNum);
+    }
-...
     	return PS3EyeMulticamGetFrame(pBuffer);
+    }
     void ofxPS3::initPS3(int width,int height, int framerate)
     void ofxPS3::initPS3(int width, int height, int framerate)
+    {
     	PS3EyeMulticamOpen(camNum, height==480?VGA:QVGA, framerate);
     	printf("selecting format...\n");
     	PS3EyeMulticamOpen(camNum, (height==480) ? VGA:QVGA, framerate);
     	PS3EyeMulticamLoadSettings(".\\data\\cameras.xml");
     	// get stitched image width
     	PS3EyeMulticamGetFrameDimensions(camWidth, camHeight);
-...
     	PS3EyeMulticamStop();
     	Sleep(50);
     	PS3EyeMulticamSaveSettings(".\\data\\cameras.xml");
     	PS3EyeMulticamClose();
     	PS3EyeMulticamClose();
     	delete [] pBuffer;
     	// this delete the temp settings.xml which is saved to data/cameras.xml
     	remove("settings.xml");
+    }

     #include "ContourFinder.h"
     //--------------------------------------------------------------------------------
     static int qsort_carea_compare( const void* _a, const void* _b) {
     static int qsort_carea_compare( const void* _a, const void* _b)
+    {
     	int out = 0;
     	// pointers, ugh.... sorry about this
     	CvSeq* a = *((CvSeq **)_a);
-...
     	float areab = fabs(cvContourArea(b, CV_WHOLE_SEQ));
     	// note, based on the -1 / 1 flip
     	// we sort biggest to smallest, not smallest to biggest
     	if( areaa > areab ) { out = -1; }
     	else {                out =  1; }
     	if( areaa > areab )		out = -1;
     	else					out =  1;
     	return out;
+    }
     //--------------------------------------------------------------------------------
     ContourFinder::ContourFinder() {
     ContourFinder::ContourFinder()
+    {
     	myMoments = (CvMoments*)malloc( sizeof(CvMoments) );
     	reset();
+    }
     //--------------------------------------------------------------------------------
     ContourFinder::~ContourFinder() {
     ContourFinder::~ContourFinder()
+    {
     	free( myMoments );
+    }
     //--------------------------------------------------------------------------------
     void ContourFinder::reset() {
     void ContourFinder::reset()
+    {
         blobs.clear();
         nBlobs = 0;
+    }
-...
     									  int maxArea,
     									  int nConsidered,
     									  bool bFindHoles,
                                           bool bUseApproximation) {
                                           bool bUseApproximation)
+    {
     	reset();
     	// opencv will clober the image it detects contours on, so we want to
-...
         // 320x240 image better to make two ContourFinder objects then to use
         // one, because you will get penalized less.
     	if( inputCopy.width == 0 ) {
     	if( inputCopy.width == 0 )
+    	{
     		inputCopy.allocate( input.width, input.height );
     		inputCopy = input;
     	} else {
     		if( inputCopy.width == input.width && inputCopy.height == input.height ) {
+    	}
     	else
+    	{
     		if( inputCopy.width == input.width && inputCopy.height == input.height )
     			inputCopy = input;
     		} else {
     		else
+    		{
     			// we are allocated, but to the wrong size --
     			// been checked for memory leaks, but a warning:
     			// be careful if you call this function with alot of different
-...
     	nCvSeqsFound = 0;
     	// put the contours from the linked list, into an array for sorting
     	while( (contour_ptr != NULL) ) {
     	while( (contour_ptr != NULL) )
+    	{
     		float area = fabs( cvContourArea(contour_ptr, CV_WHOLE_SEQ) );
     		if( (area > minArea) && (area < maxArea) ) {
                     if (nCvSeqsFound < TOUCH_MAX_CONTOUR_LENGTH){
     		if( (area > minArea) && (area < maxArea) )
+    		{
                     if (nCvSeqsFound < TOUCH_MAX_CONTOUR_LENGTH)
+    				{
     				cvSeqBlobs[nCvSeqsFound] = contour_ptr;	 // copy the pointer
                     nCvSeqsFound++;
+    				}
-...
+    	}
     	// sort the pointers based on size
     	if( nCvSeqsFound > 0 ) {
     	if( nCvSeqsFound > 0 )
+    	{
     		qsort( cvSeqBlobs, nCvSeqsFound, sizeof(CvSeq*), qsort_carea_compare);
+    	}
     	// now, we have nCvSeqsFound contours, sorted by size in the array
         // cvSeqBlobs let's get the data out and into our structures that we like
     	for( int i = 0; i < MIN(nConsidered, nCvSeqsFound); i++ ) {
     	for( int i = 0; i < MIN(nConsidered, nCvSeqsFound); i++ )
+    	{
     		blobs.push_back( Blob() );
     		float area = cvContourArea( cvSeqBlobs[i], CV_WHOLE_SEQ );
-...
     		// assign other parameters
     		blobs[i].area                = fabs(area);
     		blobs[i].hole                = area < 0 ? true : false;
     		blobs[i].length 			 = cvArcLength(cvSeqBlobs[i]);
     		blobs[i].centroid.x			 = (int) (myMoments->m10 / myMoments->m00);
     		blobs[i].centroid.y 		 = (int) (myMoments->m01 / myMoments->m00);
     		blobs[i].lastCentroid.x 	 = (int) 0;
     		blobs[i].lastCentroid.y 	 = (int) 0;
     		blobs[i].length 			 = cvArcLength(cvSeqBlobs[i]);
     		// AlexP
     		// The cast to int causes errors in tracking since centroids are calculated in
     		// floats and they migh land between integer pixel values (which is what we really want)
     		// This not only makes tracking more accurate but also more fluid
     		blobs[i].centroid.x			 = (myMoments->m10 / myMoments->m00);
     		blobs[i].centroid.y 		 = (myMoments->m01 / myMoments->m00);
     		blobs[i].lastCentroid.x 	 = 0;
     		blobs[i].lastCentroid.y 	 = 0;
     		// get the points for the blob:
     		CvPoint           pt;
     		CvSeqReader       reader;
     		cvStartReadSeq( cvSeqBlobs[i], &reader, 0 );
         	for( int j=0; j < min(TOUCH_MAX_CONTOUR_LENGTH, cvSeqBlobs[i]->total); j++ ) {
         	for( int j=0; j < min(TOUCH_MAX_CONTOUR_LENGTH, cvSeqBlobs[i]->total); j++ )
+    		{
     			CV_READ_SEQ_ELEM( pt, reader );
                 blobs[i].pts.push_back( ofPoint((float)pt.x, (float)pt.y) );
+    		}
     		blobs[i].nPts = blobs[i].pts.size();
+    	}
         nBlobs = blobs.size();

     	isCalibrating = false;
+    }
     BlobTracker::~BlobTracker(){
     BlobTracker::~BlobTracker()
+    {
     	delete calibrate;
+    }
     void BlobTracker::passInCalibration(CalibrationUtils* calibrater) {
     void BlobTracker::passInCalibration(CalibrationUtils* calibrater)
+    {
         calibrate = calibrater;
+    }
-...
     	for(int i=0; i<newBlobs->nBlobs; i++)
     		newBlobs->blobs[i].id=-1;
     	// STEP 1: Blob matching
     	//
     	//go through all tracked blobs to compute nearest new point
     	for(int i=0; i<trackedBlobs.size(); i++)
     	for(int i = 0; i < trackedBlobs.size(); i++)
+    	{
     		/******************************************************************
     		 * *****************TRACKING FUNCTION TO BE USED*******************
-...
     		 *****************************************************************/
     		int winner = trackKnn(newBlobs, &(trackedBlobs[i]), 3, 0);
     		if(winner==-1) //track has died, mark it for deletion
     		if(winner == -1) //track has died, mark it for deletion
+    		{
     			//SEND BLOB OFF EVENT
     			TouchEvents.messenger = trackedBlobs[i];
     			if(isCalibrating){
     			if(isCalibrating)
+    			{
     				TouchEvents.RAWmessenger = trackedBlobs[i];
     				TouchEvents.notifyRAWTouchUp(NULL);
+    			}
     			calibrate->transformDimension(TouchEvents.messenger.boundingRect.width, TouchEvents.messenger.boundingRect.height);
     			calibrate->cameraToScreenPosition(TouchEvents.messenger.centroid.x, TouchEvents.messenger.centroid.y);
     			//erase calibrated blob from map
-...
     						//SEND BLOB OFF EVENT
     						TouchEvents.messenger = trackedBlobs[j];
     						if(isCalibrating){
     						if(isCalibrating)
+    						{
     							TouchEvents.RAWmessenger = trackedBlobs[j];
     							TouchEvents.notifyRAWTouchUp(NULL);
+    						}
-...
     						//SEND BLOB OFF EVENT
     						TouchEvents.messenger = trackedBlobs[i];
     						if(isCalibrating){
     						if(isCalibrating)
+    						{
     							TouchEvents.RAWmessenger = trackedBlobs[i];
     							TouchEvents.notifyRAWTouchUp(NULL);
+    						}
-...
+    		}
+    	}
     	// AlexP
     	// save the current time since we will be using it a lot
     	int now = ofGetElapsedTimeMillis();
     	// STEP 2: Blob update
     	//
     	//--Update All Current Tracks
     	//remove every track labeled as dead (ID='-1')
     	//find every track that's alive and copy it's data from newBlobs
     	for(int i=0; i<trackedBlobs.size(); i++)
     	for(int i = 0; i < trackedBlobs.size(); i++)
+    	{
     		if(trackedBlobs[i].id==-1) //dead
+    		{
     			//erase track
     			trackedBlobs.erase(trackedBlobs.begin()+i,
     							   trackedBlobs.begin()+i+1);
     			trackedBlobs.erase(trackedBlobs.begin()+i, trackedBlobs.begin()+i+1);
     			i--; //decrement one since we removed an element
+    		}
     		else //living, so update it's data
+    		{
     			for(int j=0; j<newBlobs->nBlobs; j++)
     			for(int j = 0; j < newBlobs->nBlobs; j++)
+    			{
     				if(trackedBlobs[i].id==newBlobs->blobs[j].id)
     				if(trackedBlobs[i].id == newBlobs->blobs[j].id)
+    				{
     					//update track
     					ofPoint tempLastCentroid = trackedBlobs[i].centroid; // assign the new centroid to the old
     					trackedBlobs[i]=newBlobs->blobs[j];
     					trackedBlobs[i] = newBlobs->blobs[j];
     					trackedBlobs[i].lastCentroid = tempLastCentroid;
     					// AlexP
     					// now, filter the blob position based on MOVEMENT_FILTERING value
     					// the MOVEMENT_FILTERING ranges [0,15] so we will have that many filtering steps
     					// Here we have a simple weighted low-pass filter
     					float a = 1.0f - (float)MOVEMENT_FILTERING / 15.0f;
     					trackedBlobs[i].centroid.x = a * trackedBlobs[i].centroid.x + (1-a) * trackedBlobs[i].lastCentroid.x;
     					trackedBlobs[i].centroid.y = a * trackedBlobs[i].centroid.y + (1-a) * trackedBlobs[i].lastCentroid.y;
     					//get the Differences in position
     					trackedBlobs[i].D.set((trackedBlobs[i].centroid.x - trackedBlobs[i].lastCentroid.x) / (ofGetElapsedTimeMillis() - trackedBlobs[i].lastTimeTimeWasChecked),
     										  (trackedBlobs[i].centroid.y - trackedBlobs[i].lastCentroid.y) / (ofGetElapsedTimeMillis() - trackedBlobs[i].lastTimeTimeWasChecked));
     					trackedBlobs[i].D.set(trackedBlobs[i].centroid.x - trackedBlobs[i].lastCentroid.x,
     											trackedBlobs[i].centroid.y - trackedBlobs[i].lastCentroid.y);
     					//printf("D(%f, %f)\n", trackedBlobs[i].D.x, trackedBlobs[i].D.y);
     					//if( abs((int)trackedBlobs[i].D.x) > 1 || abs((int)trackedBlobs[i].D.y) > 1) {
     //						printf("\nUNUSUAL BLOB @ %f\n-----------------------\ntrackedBlobs[%i]\nD = (%f, %f)\nXY= (%f, %f)\nlastTimeTimeWasChecked = %f\nsitting = %f\n",
     //							   ofGetElapsedTimeMillis(),
-...
     //							   trackedBlobs[i].sitting
     //						);
     //					}
     					//calculate the accelleration
     					//calculate the acceleration
     					ofPoint tD = trackedBlobs[i].D;
     					trackedBlobs[i].maccel = sqrtf((tD.x* tD.x)+(tD.y*tD.y)/(ofGetElapsedTimeMillis() - trackedBlobs[i].lastTimeTimeWasChecked));
     					trackedBlobs[i].lastTimeTimeWasChecked = ofGetElapsedTimeMillis();
     					trackedBlobs[i].maccel = sqrtf((tD.x* tD.x)+(tD.y*tD.y)/(now - trackedBlobs[i].lastTimeTimeWasChecked));
     					//calculate the age
     					trackedBlobs[i].age = ofGetElapsedTimef() - trackedBlobs[i].downTime;
     					//if not moving more than min_movement_threshold then set to same position as last frame
     		            if(trackedBlobs[i].maccel < MIN_MOVEMENT_THRESHOLD)
     					{	//this helps avoid jittery blobs
     						trackedBlobs[i].centroid.x = trackedBlobs[i].lastCentroid.x;
     						trackedBlobs[i].centroid.y = trackedBlobs[i].lastCentroid.y;
+                        }
     					//set sitting (held length)
                         if(trackedBlobs[i].maccel < 7)
     					{	//1 more frame of sitting
     						if(trackedBlobs[i].sitting != -1)
     						trackedBlobs[i].sitting = ofGetElapsedTimef() - trackedBlobs[i].downTime;
     							trackedBlobs[i].sitting = ofGetElapsedTimef() - trackedBlobs[i].downTime;
+    					}
     					else {
     					else
     						trackedBlobs[i].sitting = -1;
+    					}
     					//printf("time: %f\n", ofGetElapsedTimeMillis());
     					//printf("%i age: %f, downTimed at: %f\n", i, trackedBlobs[i].age, trackedBlobs[i].downTime);
     					//if blob has been 'holding/sitting' for 1 second send a held event
     					if(trackedBlobs[i].sitting > 1.0f){
     					if(trackedBlobs[i].sitting > 1.0f)
+    					{
     						//SEND BLOB HELD EVENT
     						TouchEvents.messenger = trackedBlobs[i];
     						if(isCalibrating){
     						if(isCalibrating)
+    						{
     							TouchEvents.RAWmessenger = trackedBlobs[i];
     							TouchEvents.notifyRAWTouchHeld(NULL);
+    						}
-...
     						calibrate->cameraToScreenPosition(TouchEvents.messenger.lastCentroid.x, TouchEvents.messenger.lastCentroid.y);
     						//Calibrated dx/dy
     						TouchEvents.messenger.D.set((TouchEvents.messenger.centroid.x - TouchEvents.messenger.lastCentroid.x) / (ofGetElapsedTimeMillis() - TouchEvents.messenger.lastTimeTimeWasChecked),
     													(TouchEvents.messenger.centroid.y - TouchEvents.messenger.lastCentroid.y) / (ofGetElapsedTimeMillis() - TouchEvents.messenger.lastTimeTimeWasChecked));
     						TouchEvents.messenger.D.set(trackedBlobs[i].centroid.x - trackedBlobs[i].lastCentroid.x,
     												trackedBlobs[i].centroid.y - trackedBlobs[i].lastCentroid.y);
     						TouchEvents.messenger.lastTimeTimeWasChecked = ofGetElapsedTimeMillis();
     						//calibrated accelleration
     						//calibrated acceleration
     						ofPoint tD2 = TouchEvents.messenger.D;
     						TouchEvents.messenger.maccel = sqrtf((tD2.x* tD2.x)+(tD2.y*tD2.y)/(ofGetElapsedTimeMillis() - trackedBlobs[i].lastTimeTimeWasChecked));
     						TouchEvents.messenger.maccel = sqrtf((tD2.x* tD2.x)+(tD2.y*tD2.y)/(now - TouchEvents.messenger.lastTimeTimeWasChecked));
     						TouchEvents.messenger.lastTimeTimeWasChecked = now;
     						//add to calibration map
     						calibratedBlobs[TouchEvents.messenger.id] = TouchEvents.messenger;
-...
                             trackedBlobs[i].sitting = -1;
     						TouchEvents.notifyTouchHeld(NULL);
     					} else {
+    					}
     					else
+    					{
     						//printf("(%f, %f) -> (%f, %f) \n", trackedBlobs[i].lastCentroid.x, trackedBlobs[i].lastCentroid.y, trackedBlobs[i].centroid.x, trackedBlobs[i].centroid.y);
     						//SEND BLOB MOVED EVENT
     						TouchEvents.messenger = trackedBlobs[i];
     						if(isCalibrating){
     						if(isCalibrating)
+    						{
     							TouchEvents.RAWmessenger = trackedBlobs[i];
     							TouchEvents.notifyRAWTouchMoved(NULL);
+    						}
-...
     						calibrate->transformDimension(TouchEvents.messenger.boundingRect.width, TouchEvents.messenger.boundingRect.height);
     						calibrate->cameraToScreenPosition(TouchEvents.messenger.centroid.x, TouchEvents.messenger.centroid.y);
     						calibrate->cameraToScreenPosition(TouchEvents.messenger.lastCentroid.x, TouchEvents.messenger.lastCentroid.y);
     						//Calibrated dx/dy
     						TouchEvents.messenger.D.set((TouchEvents.messenger.centroid.x - TouchEvents.messenger.lastCentroid.x) / (ofGetElapsedTimeMillis() - TouchEvents.messenger.lastTimeTimeWasChecked),
     													(TouchEvents.messenger.centroid.y - TouchEvents.messenger.lastCentroid.y) / (ofGetElapsedTimeMillis() - TouchEvents.messenger.lastTimeTimeWasChecked));
     						TouchEvents.messenger.lastTimeTimeWasChecked = ofGetElapsedTimeMillis();
     						TouchEvents.messenger.D.set(trackedBlobs[i].centroid.x - trackedBlobs[i].lastCentroid.x,
     											trackedBlobs[i].centroid.y - trackedBlobs[i].lastCentroid.y);
     						//printf("d(%0.4f, %0.4f)\n", TouchEvents.messenger.D.x, TouchEvents.messenger.D.y);
     						//calibrated accelleration
     						//calibrated acceleration
     						ofPoint tD2 = TouchEvents.messenger.D;
     						TouchEvents.messenger.maccel = sqrtf((tD2.x* tD2.x)+(tD2.y*tD2.y)/(ofGetElapsedTimeMillis() - trackedBlobs[i].lastTimeTimeWasChecked));
     						TouchEvents.messenger.maccel = sqrtf((tD2.x* tD2.x)+(tD2.y*tD2.y)/(now - TouchEvents.messenger.lastTimeTimeWasChecked));
     						TouchEvents.messenger.lastTimeTimeWasChecked = now;
     						//add to calibration map
     						calibratedBlobs[TouchEvents.messenger.id] = TouchEvents.messenger;
     						TouchEvents.notifyTouchMoved(NULL);
+    					}
     					// AlexP
     					// The last lastTimeTimeWasChecked is updated at the end after all acceleration values are calculated
     					trackedBlobs[i].lastTimeTimeWasChecked = now;
+    				}
+    			}
+    		}
+    	}
     	// STEP 3: add tracked blobs to TouchEvents
     	//--Add New Living Tracks
     	//now every new blob should be either labeled with a tracked ID or\
     	//have ID of -1... if the ID is -1... we need to make a new track
     	for(int i=0; i<newBlobs->nBlobs; i++)
     	for(int i = 0; i < newBlobs->nBlobs; i++)
+    	{
     		if(newBlobs->blobs[i].id==-1)
+    		{
-...
     			//Add to blob messenger
     			TouchEvents.messenger = newBlobs->blobs[i];
     			if(isCalibrating){
     			if(isCalibrating)
+    			{
     				TouchEvents.RAWmessenger = newBlobs->blobs[i];
     				TouchEvents.notifyRAWTouchDown(NULL);
+    			}
                 calibrate->transformDimension(TouchEvents.messenger.boundingRect.width, TouchEvents.messenger.boundingRect.height);
                 calibrate->cameraToScreenPosition(TouchEvents.messenger.centroid.x, TouchEvents.messenger.centroid.y);
     			//add to calibrated blob map
-...
     			//Send Event
     			TouchEvents.notifyTouchDown(NULL);
     			trackedBlobs.push_back(newBlobs->blobs[i]);
+    		}
+    	}
+    }
     std::map<int, Blob> BlobTracker::getTrackedBlobs(){
     std::map<int, Blob> BlobTracker::getTrackedBlobs()
+    {
         return calibratedBlobs;
+    }
-...
     			winner = iter->first;
+    		}
+    	}
     	return winner;
+    }

     		int					color;
             //----------------------------------------
             Blob() {
             Blob()
+    		{
                 area 		= 0.0f;
                 length 		= 0.0f;
                 hole 		= false;
-...
+            }
             //----------------------------------------
             void drawContours(float x = 0, float y = 0, float inputWidth = ofGetWidth(), float inputHeight = ofGetHeight(), float outputWidth = ofGetWidth(), float outputHeight = ofGetHeight()) {
             void drawContours(float x = 0, float y = 0, float inputWidth = ofGetWidth(), float inputHeight = ofGetHeight(), float outputWidth = ofGetWidth(), float outputHeight = ofGetHeight())
+    		{
                 glPushMatrix();
                     glTranslatef(x + angleBoundingRect.x/inputWidth * outputWidth, y + angleBoundingRect.y/inputHeight * outputHeight, 0.0f);
                     glRotatef(-angle, 0.0f, 0.0f, 1.0f);
-...
     			ofNoFill();
                 ofSetColor(0xFF0099);
                 ofBeginShape();
                 for (int i = 0; i < nPts; i++){
                 for (int i = 0; i < nPts; i++)
                        ofVertex(x + pts[i].x/inputWidth * outputWidth, y + pts[i].y/(inputHeight) * outputHeight);
+                }
                 ofEndShape(true);
+            }
     };

     #include "ofxOpenCv.h"
     #include "Blob.h"
     #define TOUCH_MAX_CONTOURS 128
     #define TOUCH_MAX_CONTOUR_LENGTH 1024
     #define TOUCH_MAX_CONTOURS			128
     #define TOUCH_MAX_CONTOUR_LENGTH	1024
     class ContourFinder {
     class ContourFinder
+    {
       public:
         ContourFinder();

     #include "../Events/TouchMessenger.h"
     #include "../Calibration/CalibrationUtils.h"
     class BlobTracker : public TouchListener
+    {
     public:
     	BlobTracker();
-...
     	CalibrationUtils* calibrate;
     	bool isCalibrating;
     	int MIN_MOVEMENT_THRESHOLD;
     	int MOVEMENT_FILTERING;
     	std::map<int, Blob> getTrackedBlobs();
     private:

     	controls->mGlobals->mTextColor.b = 0;
     	controls->mGlobals->mTextColor.a = 1;
     	//button color
     	controls->mGlobals->mButtonColor.r = .9;
     	controls->mGlobals->mButtonColor.g = 1;
     	controls->mGlobals->mButtonColor.r = 1;
     	controls->mGlobals->mButtonColor.g = 0;
     	controls->mGlobals->mButtonColor.b = 0;
     	controls->mGlobals->mButtonColor.a = .8;
     	//slider tip color
-...
     	ofxGuiPanel* trackPanel = controls->addPanel(appPtr->trackedPanel, "Tracked Image", 386, 270, OFXGUI_PANEL_BORDER, OFXGUI_PANEL_SPACING);
     	trackPanel->addButton(appPtr->trackedPanel_darkblobs, "Inverse", OFXGUI_BUTTON_HEIGHT, OFXGUI_BUTTON_HEIGHT, kofxGui_Button_Off, kofxGui_Button_Switch, "");
     	trackPanel->addSlider(appPtr->trackedPanel_threshold, "Image Threshold", 140, 13, 0.0f, 255.0f, filter->threshold, kofxGui_Display_Int, 0);
     	trackPanel->addSlider(appPtr->trackedPanel_min_movement, "Movement Threshold", 140, 13, 0.0f, 15.0f, tracker.MIN_MOVEMENT_THRESHOLD, kofxGui_Display_Int, 0);
     	trackPanel->addSlider(appPtr->trackedPanel_min_movement, "Movement Filtering", 140, 13, 0.0f, 15.0f, tracker.MOVEMENT_FILTERING, kofxGui_Display_Int, 0);
     	trackPanel->addSlider(appPtr->trackedPanel_min_blob_size, "Min Blob Size", 140, 13, 1.0f, 500.0f, MIN_BLOB_SIZE, kofxGui_Display_Int, 0);
     	trackPanel->addSlider(appPtr->trackedPanel_max_blob_size, "Max Blob Size", 140, 13, 1.0f, 1000.0f, MAX_BLOB_SIZE, kofxGui_Display_Int, 0);
     	trackPanel->mObjHeight = 100;
-...
     	//Threshold
     	controls->update(appPtr->trackedPanel_threshold, kofxGui_Set_Bool, &appPtr->filter->threshold, sizeof(float));
     	//Min Movement
     	controls->update(appPtr->trackedPanel_min_movement, kofxGui_Set_Bool, &appPtr->tracker.MIN_MOVEMENT_THRESHOLD, sizeof(float));
     	controls->update(appPtr->trackedPanel_min_movement, kofxGui_Set_Bool, &appPtr->tracker.MOVEMENT_FILTERING, sizeof(float));
     	//Min Blob Size
     	controls->update(appPtr->trackedPanel_min_blob_size, kofxGui_Set_Bool, &appPtr->MIN_BLOB_SIZE, sizeof(float));
     	//Max Blob Size
-...
     			break;
     		case trackedPanel_min_movement:
     			if(length == sizeof(float))
     				tracker.MIN_MOVEMENT_THRESHOLD = *(float*)data;
     				tracker.MOVEMENT_FILTERING = *(float*)data;
     			break;
     		case trackedPanel_min_blob_size:
     			if(length == sizeof(float))

     #include "TUIO.h"
     TUIO::TUIO() {
     TUIO::TUIO()
+    {
+    }
     TUIO::~TUIO() {
     TUIO::~TUIO()
+    {
     	// this could be useful for whenever we get rid of an object
+    }
     void TUIO::setup(const char* host, int port, int flashport) {
     void TUIO::setup(const char* host, int port, int flashport)
+    {
     	localHost = host;
     	TUIOPort = port;
     	TUIOFlashPort = flashport;
     	frameseq = 0;
     	//FOR Flash/XML
     	//FOR TCP
     	bIsConnected = m_tcpServer.setup(TUIOFlashPort);
     	//FOR OSC
     	TUIOSocket.setup(localHost, TUIOPort);
-...
+    {
     	frameseq += 1;
     	//if sending OSC (not TCP)
     	if(bOSCMode){
     	// if sending OSC (not TCP)
     	if(bOSCMode)
+    	{
     		ofxOscBundle b;
     		ofxOscMessage alive;
     		// Sends alive message - saying 'Hey, there's no alive blobs'
     		alive.setAddress("/tuio/2Dcur");
     		alive.addStringArg("alive");
     		// Send fseq message
     		ofxOscMessage fseq;
     		fseq.setAddress( "/tuio/2Dcur" );
     		fseq.addStringArg( "fseq" );
     		fseq.addIntArg(frameseq);
     		if(blobs->size() == 0)
+    		{
     			ofxOscMessage source;
     			source.setAddress("/tuio/2Dcur");
     			source.addStringArg("source");
     			source.addStringArg("CCV");
     			//Sends alive message - saying 'Hey, there's no alive blobs'
     			ofxOscMessage alive;
     			alive.setAddress("/tuio/2Dcur");
     			alive.addStringArg("alive");
     			//Send fseq message
     			ofxOscMessage fseq;
     			fseq.setAddress("/tuio/2Dcur" );
     			fseq.addStringArg( "fseq" );
     			fseq.addIntArg(frameseq);
     			b.addMessage( source ); //add message to bundle
     			b.addMessage( alive ); //add message to bundle
     			b.addMessage( fseq ); //add message to bundle
     			TUIOSocket.sendBundle( b ); //send bundle
     			b.addMessage( alive );		// add message to bundle
     			b.addMessage( fseq );		// add message to bundle
     			TUIOSocket.sendBundle( b ); // send bundle
+    		}
     		else //actually send the blobs
     		else // actually send the blobs
+    		{
     			ofxOscMessage source;
     			source.setAddress("/tuio/2Dcur");
     			source.addStringArg("source");
     			source.addStringArg("CCV");
     			b.addMessage( source ); //add message to bundle
     			//Send alive message of all alive IDs
     			ofxOscMessage alive;
     			alive.setAddress("/tuio/2Dcur");
     			alive.addStringArg("alive");
     			std::map<int, Blob>::iterator this_blobID;
     			for(this_blobID = blobs->begin(); this_blobID != blobs->end(); this_blobID++)
     			map<int, Blob>::iterator blob;
     			for(blob = blobs->begin(); blob != blobs->end(); blob++)
+    			{
     				alive.addIntArg(this_blobID->second.id); //Get list of ALL active IDs
+    			}
     			b.addMessage( alive ); //add message to bundle
     			map<int, Blob>::iterator this_blob;
     			for(this_blob = blobs->begin(); this_blob != blobs->end(); this_blob++)
+    			{
     				// omit point (0,0) since this means that we are outside of the range
     				if(blob->second.centroid.x == 0 && blob->second.centroid.y == 0)
     					continue;
     				//Set Message
     				ofxOscMessage set;
     				set.setAddress( "/tuio/2Dcur" );
     				set.addStringArg("set");
     				set.addIntArg(this_blob->second.id); //id
     				set.addFloatArg(this_blob->second.centroid.x);  // x
     				set.addFloatArg(this_blob->second.centroid.y); // y
     				set.addFloatArg(this_blob->second.D.x); //dX
     				set.addFloatArg(this_blob->second.D.y); //dY
     				set.addFloatArg(this_blob->second.maccel); //m
     				// this proprietary message extension includes the ABB width & height
     				if(bHeightWidth){
     					set.addFloatArg(this_blob->second.boundingRect.width); // wd
     					set.addFloatArg(this_blob->second.boundingRect.height);// ht
     				set.addIntArg(blob->second.id);				// id
     				set.addFloatArg(blob->second.centroid.x);	// x
     				set.addFloatArg(blob->second.centroid.y);	// y
     				set.addFloatArg(blob->second.D.x);			// dX
     				set.addFloatArg(blob->second.D.y);			// dY
     				set.addFloatArg(blob->second.maccel);		// m
     				if(bHeightWidth)
+    				{
     					set.addFloatArg(blob->second.boundingRect.width);	// wd
     					set.addFloatArg(blob->second.boundingRect.height);	// ht
+    				}
     				b.addMessage( set ); //add message to bundle
     				b.addMessage( set );							// add message to bundle
     				alive.addIntArg(blob->second.id);				// add blob to list of ALL active IDs
+    			}
     // 			// Send alive message of all alive IDs
     // 			ofxOscMessage alive;
     // 			alive.setAddress("/tuio/2Dcur");
     // 			alive.addStringArg("alive");
     //			std::map<int, Blob>::iterator this_blobID;
     //			for(this_blobID = blobs->begin(); this_blobID != blobs->end(); this_blobID++)
     //			{
     //				alive.addIntArg(this_blobID->second.id); //Get list of ALL active IDs
     //			}
     			//Send fseq message
     			ofxOscMessage fseq;
     			fseq.setAddress( "/tuio/2Dcur" );
     			fseq.addStringArg( "fseq" );
     			fseq.addIntArg(frameseq);
     			b.addMessage( fseq ); //add message to bundle
     //			ofxOscMessage fseq;
     //			fseq.setAddress( "/tuio/2Dcur" );
     //			fseq.addStringArg( "fseq" );
     //			fseq.addIntArg(frameseq);
     			b.addMessage( alive );		//add message to bundle
     			b.addMessage( fseq );		//add message to bundle
     			TUIOSocket.sendBundle( b ); //send bundle
+    		}
     	}else if(bTCPMode) //else, if Flash/XML mode
+    	}
     	else if(bTCPMode) // else, if TCP (flash) mode
+    	{
     		if(blobs->size() == 0){
     		if(blobs->size() == 0)
+    		{
     			m_tcpServer.sendToAll("<OSCPACKET ADDRESS=\"127.0.0.1\" PORT=\""+ofToString(TUIOPort)+"\" TIME=\""+ofToString(ofGetElapsedTimef())+"\">" +
     							 "<MESSAGE NAME=\"/tuio/2Dcur\">"+
     							 "<ARGUMENT TYPE=\"s\" VALUE=\"alive\"/>"+
-...
     		else
+    		{
     			string setBlobsMsg;
     			string aliveBeginMsg = "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"alive\"/>";
     			string aliveEndMsg = "</MESSAGE>";
     			string aliveBlobsMsg;
     			map<int, Blob>::iterator this_blob;
     			for(this_blob = blobs->begin(); this_blob != blobs->end(); this_blob++)
     			map<int, Blob>::iterator blob;
     			for(blob = blobs->begin(); blob != blobs->end(); blob++)
+    			{
     				//if sending height and width
     				if(bHeightWidth){
     					setBlobsMsg += "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"set\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(this_blob->second.id)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.centroid.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.centroid.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.D.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.D.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.maccel)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.boundingRect.width)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.boundingRect.height)+"\"/>"+
     				// omit point (0,0) since this means that we are outside of the range
     				if(blob->second.centroid.x == 0 && blob->second.centroid.y == 0)
     					continue;
     				// if sending height and width
     				if(bHeightWidth)
+    				{
     					setBlobsMsg += "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"set\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(blob->second.id)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.centroid.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.centroid.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.D.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.D.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.maccel)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.boundingRect.width)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.boundingRect.height)+"\"/>"+
     					"</MESSAGE>";
+    				}
     				else{
     					setBlobsMsg += "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"set\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(this_blob->second.id)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.centroid.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.centroid.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.D.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.D.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(this_blob->second.maccel)+"\"/>"+
     				else
+    				{
     					setBlobsMsg += "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"set\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(blob->second.id)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.centroid.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.centroid.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.D.x)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.D.y)+"\"/>"+
     					"<ARGUMENT TYPE=\"f\" VALUE=\""+ofToString(blob->second.maccel)+"\"/>"+
     					"</MESSAGE>";
+    				}
     				aliveBlobsMsg += "<ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(blob->second.id)+"\"/>";
+    			}
     			string aliveBeginMsg = "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"alive\"/>";
     // 			std::map<int, Blob>::iterator this_blobID;
     // 			for(this_blobID = blobs->begin(); this_blobID != blobs->end(); this_blobID++)
     // 			{
     // 				aliveBlobsMsg += "<ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(this_blobID->second.id)+"\"/>";
     // 			}
     			string aliveBlobsMsg;
     			std::map<int, Blob>::iterator this_blobID;
     			for(this_blobID = blobs->begin(); this_blobID != blobs->end(); this_blobID++)
+    			{
     				aliveBlobsMsg += "<ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(this_blobID->second.id)+"\"/>";
+    			}
     			string aliveEndMsg = "</MESSAGE>";
     			string fseq = "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"fseq\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(frameseq)+"\"/></MESSAGE>";
     			m_tcpServer.sendToAll("<OSCPACKET ADDRESS=\"127.0.0.1\" PORT=\""+ofToString(TUIOPort)+"\" TIME=\""+ofToString(ofGetElapsedTimef())+"\">" +
     			string fseq = "<MESSAGE NAME=\"/tuio/2Dcur\"><ARGUMENT TYPE=\"s\" VALUE=\"fseq\"/><ARGUMENT TYPE=\"i\" VALUE=\""+ofToString(frameseq) + "\"/></MESSAGE>";
     			m_tcpServer.sendToAll("<OSCPACKET ADDRESS=\"127.0.0.1\" PORT=\"" +
     									ofToString(TUIOPort) + "\" TIME=\""+ofToString(ofGetElapsedTimef()) + "\">" +
     									setBlobsMsg + aliveBeginMsg + aliveBlobsMsg + aliveEndMsg + fseq + "</OSCPACKET>");
+    		}
+    	}

     #include "ofxOsc.h"
     #include "ofxNetwork.h"
     class TUIO {
     class TUIO
+    {
     	public:
     		TUIO();
     		~TUIO();

     	printf("Calibration is setup!\n\n");
+    }
     void Calibration::passInContourFinder(int numBlobs, vector<Blob> blobs) {
     void Calibration::passInContourFinder(int numBlobs, vector<Blob> blobs)
+    {
         contourFinder.nBlobs = numBlobs;
     	contourFinder.blobs  = blobs;
+    }
     void Calibration::passInTracker(BlobTracker *trackerIn) {
     void Calibration::passInTracker(BlobTracker *trackerIn)
+    {
     	tracker = trackerIn;
     	tracker->passInCalibration(&calibrate);
+    }
-...
     /******************************
      *		  CALIBRATION
      *******************************/
     void Calibration::doCalibration(){
     void Calibration::doCalibration()
+    {
     	//Change the background color to black
     	ofSetColor(0x000000);
     	ofFill();
-...
+    	}
+    }
     void Calibration::drawCalibrationPointsAndBox(){
     void Calibration::drawCalibrationPointsAndBox()
+    {
         //this all has to do with getting the angle for loading circle
         arcAngle = 0;
     	std::map<int, Blob> trackedBlobs;
-...
     		   calibrate.screenBB.getWidth() * ofGetWidth(), calibrate.screenBB.getHeight() * ofGetHeight());
+    }
     void Calibration::drawCalibrationBlobs(){
     void Calibration::drawCalibrationBlobs()
+    {
     	//find blobs
     	std::map<int, Blob> trackedBlobs;
     	std::map<int, Blob>::iterator iter;

     	_camHeight = 240;
+    }
     CalibrationUtils::~CalibrationUtils(){
     CalibrationUtils::~CalibrationUtils()
+    {
         delete screenPoints;
     	delete cameraPoints;
         delete triangles;
-...
     //--------------------------------------------------------------
     //	Load Settings from the config.xml file
     //--------------------------------------------------------------
     void CalibrationUtils::loadXMLSettings(){
     void CalibrationUtils::loadXMLSettings()
+    {
     	bGoToNextStep = false;
     	// Can this load via http?
     	if( calibrationXML.loadFile("calibration.xml")){
     	if( calibrationXML.loadFile("calibration.xml"))
     		//WOOT!
     		message = "Calibration Loaded!";
     	}else{
     	else
     		//FAIL!
     		message = "No calibration Found...";
     		// GENERATE DEFAULT XML DATA WHICH WILL BE SAVED INTO THE CONFIG
+    	}
     	bool bboxRoot = true;
     	bool screenRoot = true;
-...
     	setGrid(GRID_X, GRID_Y);
     	//Bounding Box Points
     	if(bboxRoot){
     	if(bboxRoot)
+    	{
     	    vector2df ul(calibrationXML.getValue("SCREEN:BOUNDINGBOX:ulx", 0.000000),calibrationXML.getValue("SCREEN:BOUNDINGBOX:uly", 0.000000));
     	    vector2df lr(calibrationXML.getValue("SCREEN:BOUNDINGBOX:lrx", 1.000000),calibrationXML.getValue("SCREEN:BOUNDINGBOX:lry", 1.000000));
     		rect2df boundingbox(ul, lr);
     		setScreenBBox(boundingbox);
     	}else{
     		setScreenScale(1.0f);
+    	}
     	else
     		setScreenScale(1.0f);
     	//Calibration Points
     	if(screenRoot)
-...
     		//lets see how many <STROKE> </STROKE> tags there are in the xml file
     		int numDragTags = calibrationXML.getNumTags("SCREEN:POINT");
     			//if there is at least one <POINT> tag we can read the list of points
     			if(numDragTags > 0){
     		//if there is at least one <POINT> tag we can read the list of points
     		if(numDragTags > 0)
+    		{
     			//we push into the last POINT tag this temporarirly treats the tag as the document root.
     			calibrationXML.pushTag("SCREEN:POINT", numDragTags-1);
     				//we push into the last POINT tag this temporarirly treats the tag as the document root.
     				calibrationXML.pushTag("SCREEN:POINT", numDragTags-1);
     			//we see how many points we have stored in <POINT> tags
     			int numPtTags = calibrationXML.getNumTags("POINT");
     				//we see how many points we have stored in <POINT> tags
     				int numPtTags = calibrationXML.getNumTags("POINT");
     			if(numPtTags > 0){
     			if(numPtTags > 0)
+    			{
     				//We then read those x y values into our array
     				for(int i = 0; i < numPtTags; i++){
     				for(int i = 0; i < numPtTags; i++)
+    				{
     					//the last argument of getValue can be used to specify
     					//which tag out of multiple tags you are refering to.
     					int x = calibrationXML.getValue("POINT:X", 0.000000, i);
-...
     	//Set the camera calibated box.
     	calculateBox();
     	computeCameraToScreenMap();
     //	computeCameraToScreenMap();
+    }
-...
     			float transformedX = (float)x;
     			float transformedY = (float)y;
     			//convert camera to screenspace for all possible camera positions
     			//convert camera to screen space for all possible camera positions
     			cameraToScreenSpace(transformedX, transformedY);
     			//save these into a map of transformed camera to screenspace positions
     			//save these into a map of transformed camera to screen space positions
     			cameraToScreenMap[p] = vector2df(transformedX, transformedY);
     			p++;
+    		}
-...
     	initTriangles();
     	if(bscreenPoints && bcameraPoints){
     	initScreenPoints();
     	initCameraPoints(_camWidth, _camHeight);
     	if(bscreenPoints && bcameraPoints)
+    	{
     		initScreenPoints();
     		initCameraPoints(_camWidth, _camHeight);
+    	}
+    }
-...
     	_camHeight = camHeight;
+    }
     void CalibrationUtils::initTriangles(){
     	int i,j;
     void CalibrationUtils::initTriangles()
+    {
     	int t = 0;
     	for(j=0; j<GRID_Y; j++)
     	for(int j = 0; j < GRID_Y; j++)
+    	{
     		for(i=0; i<GRID_X; i++)
     		for(int i = 0; i < GRID_X; i++)
+    		{
     			triangles[t+0] = (i+0) + ((j+0) * (GRID_X+1));
     			triangles[t+1] = (i+1) + ((j+0) * (GRID_X+1));
-...
+    {
     	int p = 0;
     	int i,j;
     	vector2df xd(screenBB.lowerRightCorner.X-screenBB.upperLeftCorner.X,0.0f);
     	vector2df yd(0.0f, screenBB.lowerRightCorner.Y-screenBB.upperLeftCorner.Y);
     	xd /= (float) GRID_X;
     	yd /= (float) GRID_Y;
     	for(j=0; j<=GRID_Y; j++)
     	for(int j = 0; j <= GRID_Y; j++)
+    	{
     		for(i=0; i<=GRID_X; i++)
     		for(int i = 0; i <= GRID_X; i++)
+    		{
     			screenPoints[p] = screenBB.upperLeftCorner + xd*i + yd*j;
     			//printf("(%d, %d) = (%f, %f)\n", i, j, screenPoints[p].X, screenPoints[p].Y);
-...
     void CalibrationUtils::initCameraPoints(int camWidth, int camHeight)
+    {
     	int p = 0;
     	int i,j;
     	for(j=0; j<=GRID_Y; j++)
     	for(int j = 0; j <= GRID_Y; j++)
+    	{
     		for(i=0; i<=GRID_X; i++)
     		for(int i = 0; i <= GRID_X; i++)
+    		{
     			cameraPoints[p] = vector2df((i * camWidth) / (float)GRID_X, (j * camHeight) / (float)GRID_Y);
     			p++;
-...
     void CalibrationUtils::setScreenScale(float s)
+    {
     	// legacy
     	float offset = (1.0f - s)*0.5f;
     	float offset = (1.0f - s) * 0.5f;
     	screenBB = rect2df(vector2df(offset,offset),vector2df(1.0f-offset,1.0f-offset));
     	initScreenPoints();
+    }
-...
     void CalibrationUtils::cameraToScreenPosition(float &x, float &y)
+    {
     	//is this right to avoid boundingbox overflow? this overflow occurs due to new angle box
     	if(y > _camHeight) y = _camHeight;
     	if(y < 0) y = 0;
     	if(x > _camWidth) x = _camWidth;
     	if(x < 0) x = 0;
     	cameraToScreenSpace(x, y);
     	int pos = (int)y * (int)_camWidth + (int)x;
     	x = cameraToScreenMap[pos].X;
     	y = cameraToScreenMap[pos].Y;
     	return;
     	//is this right to avoid boundingbox overflow? this overflow occurs due to new angle box
     // 	if(y > _camHeight) y = _camHeight;
     // 	if(y < 0) y = 0;
     // 	if(x > _camWidth) x = _camWidth;
     // 	if(x < 0) x = 0;
     //
     // 	int pos = (int)y * (int)_camWidth + (int)x;
     //
     // 	x = cameraToScreenMap[pos].X;
     // 	y = cameraToScreenMap[pos].Y;
+    }
     void CalibrationUtils::transformDimension(float &width, float &height)
-...
     	float centerX = ((maxBoxX - minBoxX)/2) + minBoxX;
     	float centerY = ((maxBoxY - minBoxY)/2) + minBoxY;
     	//Calculate x/y position of upperleft and lowerright x/y positions
     	//Calculate x/y position of upper left and lower right x/y positions
         float ulX = centerX - halfX;
         float ulY = centerY - halfY;
         float lrX = centerX + halfX;
         float lrY = centerY + halfY;
     	//Transform these x/y positions to screenspace
     	//Transform these x/y positions to screen space
     	cameraToScreenPosition(ulX, ulY);
     	cameraToScreenPosition(lrX, lrY);
-...
     	minBoxX = _camWidth;
     	maxBoxY = 0;
     	minBoxY = _camHeight;
     	//Calculate the max/min points based on cameraPoints
     	for(int i = 0; i < GRID_POINTS; i++){
     		if(cameraPoints[i].X > maxBoxX){
     			maxBoxX = cameraPoints[i].X;
+    		}
     		else if(cameraPoints[i].X < minBoxX){
     			minBoxX = cameraPoints[i].X;
+    		}
     		if(cameraPoints[i].Y > maxBoxY){
     			maxBoxY = cameraPoints[i].Y;
+    		}
     		if(cameraPoints[i].Y < minBoxY){
     			minBoxY = cameraPoints[i].Y;
+    		}
     	// Calculate the max/min points based on cameraPoints
     	for(int i = 0; i < GRID_POINTS; i++)
+    	{
     		if(cameraPoints[i].X > maxBoxX)			maxBoxX = cameraPoints[i].X;
     		else if(cameraPoints[i].X < minBoxX)	minBoxX = cameraPoints[i].X;
     		if(cameraPoints[i].Y > maxBoxY)			maxBoxY = cameraPoints[i].Y;
     		else if(cameraPoints[i].Y < minBoxY)	minBoxY = cameraPoints[i].Y;
+    	}
+    }
-...
     void CalibrationUtils::cameraToScreenSpace(float &x, float &y)
+    {
     	vector2df pt(x, y);
     	int t = findTriangleWithin(pt);
     	if(t != -1)
+    	{
     		vector2df A = cameraPoints[triangles[t+0]];
-...
     		y = transformedPos.Y;
     		return;
+    	}
     	x = 0;
     	y = 0;
     	// FIXME: what to do in the case that it's outside the mesh?
-...
     int CalibrationUtils::findTriangleWithin(vector2df pt)
+    {
     	int t;
     	for(t=0; t<GRID_INDICES; t+=3)
     	for(int t = 0; t < GRID_INDICES; t += 3)
+    	{
     		if( isPointInTriangle(pt, cameraPoints[triangles[t]], cameraPoints[triangles[t+1]], cameraPoints[triangles[t+2]]) )
+    		{
     		if(isPointInTriangle(pt, cameraPoints[triangles[t]], cameraPoints[triangles[t+1]], cameraPoints[triangles[t+2]]) )
     			return t;
+    		}
+    	}
     	return -1;
+    }
-...
     	if(bCalibrating)
+    	{
     		calibrationStep++;
     		if(calibrationStep >= GRID_POINTS)
+    		{
     			bCalibrating = false;
     			calibrationStep = 0;
     			saveCalibration();
     			calculateBox();
     			computeCameraToScreenMap();
     // 			computeCameraToScreenMap();
                 saveCalibration();
+    		}
-...
     	int numDragTags = calibrationXML.getNumTags("SCREEN:POINT");
     	//if there is at least one <POINT> tag we can read the list of points
     	if(numDragTags > 0){
     	if(numDragTags > 0)
+    	{
     		//we push into the last POINT tag this temporarirly treats the tag as the document root.
     		calibrationXML.pushTag("SCREEN:POINT", numDragTags-1);
-...
     		calibrationXML.setValue("BOUNDINGBOX:lry", screenBB.lowerRightCorner.Y);
     		//Save all the Calibration Points
     		if(GRID_POINTS > 0){
     		if(GRID_POINTS > 0)
+    		{
     			//We then read those x y values into our array
     			for(int i = 0; i < GRID_POINTS; i++){
     			for(int i = 0; i < GRID_POINTS; i++)
+    			{
     				//the last argument of getValue can be used to specify
     				//which tag out of multiple tags you are refering to.
     				calibrationXML.setValue("POINT:X", cameraPoints[i].X, i);

     class ofxNCoreVision : public ofxGuiListener
+    {
     	//ofxGUI setup stuff
     	// ofxGUI setup stuff
     	enum
+    	{
     		propertiesPanel,
-...
+    	{
     		// AlexP
     		// C++ guarantees that operator delete checks its argument for null-ness
     		delete filter;		filter=NULL;
     		delete vidGrabber;	vidGrabber=NULL;
     		delete vidPlayer;	vidPlayer=NULL;
     		delete filter;		filter = NULL;
     		delete vidGrabber;	vidGrabber = NULL;
     		delete vidPlayer;	vidPlayer = NULL;
     		#ifdef TARGET_WIN32
     			delete PS3;		PS3=NULL;
     			delete ffmv; 	ffmv=NULL;
     			delete dsvl;	dsvl=NULL;
     		delete PS3;		PS3 = NULL;
     		delete ffmv; 	ffmv = NULL;
     		delete dsvl;	dsvl = NULL;
     		#endif
+    	}

     /*
     *  ofxNCoreVision.cpp
     *  NUI Group Community Core Vision
+    *
     *  Created by NUI Group Dev Team A on 2/1/09.
     *  Copyright 2009 NUI Group. All rights reserved.
+    *
     */
     #include "ofxNCoreVision.h"
     #include "../Controls/gui.h"
     /******************************************************************************
     * The setup function is run once to perform initializations in the application
     *****************************************************************************/
     void ofxNCoreVision::_setup(ofEventArgs &e)
+    {
     	//set the title
     	ofSetWindowTitle(" Community Core Vision ");
     	//create filter
     	if ( filter == NULL )	filter = new ProcessFilters();
     	//Load Settings from config.xml file
     	loadXMLSettings();
     	//Setup Window Properties
     	ofSetWindowShape(winWidth,winHeight);
     	ofSetVerticalSync(false);	            //Set vertical sync to false for better performance?
     	//printf("Application Loaded...\n?");
     	//load camera/video
     	initDevice();
     	//set framerate
     	ofSetFrameRate(camRate * 1.3);			//This will be based on camera fps in the future
     	/*****************************************************************************************************
     	* Allocate images (needed for drawing/processing images)
     	******************************************************************************************************/
     	processedImg.allocate(camWidth, camHeight); //main Image that'll be processed.
     	processedImg.setUseTexture(false);			//We don't need to draw this so don't create a texture
     	sourceImg.allocate(camWidth, camHeight);    //Source Image
     	sourceImg.setUseTexture(false);				//We don't need to draw this so don't create a texture
     	/******************************************************************************************************/
     	//printf("Cameras Loaded...\n");
     	//Fonts - Is there a way to dynamically change font size?
     	verdana.loadFont("verdana.ttf", 8, true, true);	   //Font used for small images
     	bigvideo.loadFont("verdana.ttf", 13, true, true);  //Font used for big images.
     	//Static Images
     	background.loadImage("images/background.jpg"); //Main (Temp?) Background
     	//printf("freedom3?");
     	//GUI Controls
     	controls = ofxGui::Instance(this);
     	setupControls();
     	//printf("Controls Loaded...\n");
     	//Setup Calibration
     	calib.setup(camWidth, camHeight, &tracker);
     	//Allocate Filters
     	filter->allocate( camWidth, camHeight );
     	/*****************************************************************************************************
     	* Startup Modes
     	******************************************************************************************************/
     	//If Standalone Mode (not an addon)
     	if (bStandaloneMode)
+    	{
     		printf("Starting in standalone mode...\n\n");
     		showConfiguration = true;
+    	}
     	if (bMiniMode)
+    	{
     		showConfiguration = true;
     		bShowInterface = false;
     		printf("Starting in Mini Mode...\n\n");
     		ofSetWindowShape(190, 200); //minimized size
     		filter->bMiniMode = bMiniMode;
+    	}
     	else
+    	{
     		bShowInterface = true;
     		printf("Starting in full mode...\n\n");
+    	}
     	#ifdef TARGET_WIN32
     	    //get rid of the console window
             FreeConsole();
     	#endif
     	printf("Community Core Vision is setup!\n\n");
+    }
     /****************************************************************
     *	Load/Save config.xml file Settings
     ****************************************************************/
     void ofxNCoreVision::loadXMLSettings()
+    {
     	// TODO: a seperate XML to map keyboard commands to action
     	message = "Loading config.xml...";
     	// Can this load via http?
     	if ( XML.loadFile("config.xml"))
     		message = "Settings Loaded!\n\n";
     	else
     		message = "No Settings Found...\n\n"; //FAIL
     	//--------------------------------------------------------------
     	//  START BINDING XML TO VARS
     	//--------------------------------------------------------------
     	winWidth					= XML.getValue("CONFIG:WINDOW:WIDTH", 950);
     	winHeight					= XML.getValue("CONFIG:WINDOW:HEIGHT", 600);
     	bcamera						= XML.getValue("CONFIG:CAMERA_0:USECAMERA", 1);
     	deviceID					= XML.getValue("CONFIG:CAMERA_0:DEVICE", 0);
     	camWidth					= XML.getValue("CONFIG:CAMERA_0:WIDTH", 320);
     	camHeight					= XML.getValue("CONFIG:CAMERA_0:HEIGHT", 240);
     	camRate						= XML.getValue("CONFIG:CAMERA_0:FRAMERATE", 0);
     	videoFileName				= XML.getValue("CONFIG:VIDEO:FILENAME", "test_videos/RearDI.m4v");
     	maxBlobs					= XML.getValue("CONFIG:BLOBS:MAXNUMBER", 20);
     	bShowLabels					= XML.getValue("CONFIG:BOOLEAN:LABELS",0);
     	bDrawOutlines				= XML.getValue("CONFIG:BOOLEAN:OUTLINES",0);
     	filter->bLearnBakground		= XML.getValue("CONFIG:BOOLEAN:LEARNBG",0);
     	filter->bVerticalMirror		= XML.getValue("CONFIG:BOOLEAN:VMIRROR",0);
     	filter->bHorizontalMirror	= XML.getValue("CONFIG:BOOLEAN:HMIRROR",0);
     	//Filters
     	filter->bTrackDark			= XML.getValue("CONFIG:BOOLEAN:TRACKDARK", 0);
     	filter->bHighpass			= XML.getValue("CONFIG:BOOLEAN:HIGHPASS",1);
     	filter->bAmplify			= XML.getValue("CONFIG:BOOLEAN:AMPLIFY", 1);
     	filter->bSmooth				= XML.getValue("CONFIG:BOOLEAN:SMOOTH", 1);
     	filter->bDynamicBG			= XML.getValue("CONFIG:BOOLEAN:DYNAMICBG", 1);
     	//MODES
     	bGPUMode					= XML.getValue("CONFIG:BOOLEAN:GPU", 0);
     	bMiniMode                   = XML.getValue("CONFIG:BOOLEAN:MINIMODE",0);
     	//CONTROLS
     	tracker.MIN_MOVEMENT_THRESHOLD	= XML.getValue("CONFIG:INT:MINMOVEMENT",0);
     	MIN_BLOB_SIZE				= XML.getValue("CONFIG:INT:MINBLOBSIZE",2);
     	MAX_BLOB_SIZE				= XML.getValue("CONFIG:INT:MAXBLOBSIZE",100);
     	backgroundLearnRate			= XML.getValue("CONFIG:INT:BGLEARNRATE", 0.01f);
     	//Filter Settings
     	filter->threshold			= XML.getValue("CONFIG:INT:THRESHOLD",0);
     	filter->highpassBlur		= XML.getValue("CONFIG:INT:HIGHPASSBLUR",0);
     	filter->highpassNoise		= XML.getValue("CONFIG:INT:HIGHPASSNOISE",0);
     	filter->highpassAmp			= XML.getValue("CONFIG:INT:HIGHPASSAMP",0);
     	filter->smooth				= XML.getValue("CONFIG:INT:SMOOTH",0);
     	//NETWORK SETTINGS
     	bTUIOMode					= XML.getValue("CONFIG:BOOLEAN:TUIO",0);
     	myTUIO.bOSCMode				= XML.getValue("CONFIG:BOOLEAN:OSCMODE",1);
     	myTUIO.bTCPMode				= XML.getValue("CONFIG:BOOLEAN:TCPMODE",1);
     	myTUIO.bHeightWidth			= XML.getValue("CONFIG:BOOLEAN:HEIGHTWIDTH",0);
     	tmpLocalHost				= XML.getValue("CONFIG:NETWORK:LOCALHOST", "localhost");
     	tmpPort						= XML.getValue("CONFIG:NETWORK:TUIOPORT_OUT", 3333);
     	tmpFlashPort				= XML.getValue("CONFIG:NETWORK:TUIOFLASHPORT_OUT", 3000);
     	myTUIO.setup(tmpLocalHost.c_str(), tmpPort, tmpFlashPort); //have to convert tmpLocalHost to a const char*
     	//--------------------------------------------------------------
     	//  END XML SETUP
+    }
     void ofxNCoreVision::saveSettings()
+    {
     	XML.setValue("CONFIG:CAMERA_0:USECAMERA", bcamera);
     	XML.setValue("CONFIG:CAMERA_0:DEVICE", deviceID);
     	XML.setValue("CONFIG:CAMERA_0:WIDTH", camWidth);
     	XML.setValue("CONFIG:CAMERA_0:HEIGHT", camHeight);
     	XML.setValue("CONFIG:CAMERA_0:FRAMERATE", camRate);
     	XML.setValue("CONFIG:BOOLEAN:PRESSURE",bShowPressure);
     	XML.setValue("CONFIG:BOOLEAN:LABELS",bShowLabels);
     	XML.setValue("CONFIG:BOOLEAN:OUTLINES",bDrawOutlines);
     	XML.setValue("CONFIG:BOOLEAN:LEARNBG", filter->bLearnBakground);
     	XML.setValue("CONFIG:BOOLEAN:VMIRROR", filter->bVerticalMirror);
     	XML.setValue("CONFIG:BOOLEAN:HMIRROR", filter->bHorizontalMirror);
     	XML.setValue("CONFIG:BOOLEAN:TRACKDARK", filter->bTrackDark);
     	XML.setValue("CONFIG:BOOLEAN:HIGHPASS", filter->bHighpass);
     	XML.setValue("CONFIG:BOOLEAN:AMPLIFY", filter->bAmplify);
     	XML.setValue("CONFIG:BOOLEAN:SMOOTH", filter->bSmooth);
     	XML.setValue("CONFIG:BOOLEAN:DYNAMICBG", filter->bDynamicBG);
     	XML.setValue("CONFIG:BOOLEAN:GPU", bGPUMode);
     	XML.setValue("CONFIG:INT:MINMOVEMENT", tracker.MIN_MOVEMENT_THRESHOLD);
     	XML.setValue("CONFIG:INT:MINBLOBSIZE", MIN_BLOB_SIZE);
     	XML.setValue("CONFIG:INT:MAXBLOBSIZE", MAX_BLOB_SIZE);
     	XML.setValue("CONFIG:INT:BGLEARNRATE", backgroundLearnRate);
     	XML.setValue("CONFIG:INT:THRESHOLD", filter->threshold);
     	XML.setValue("CONFIG:INT:HIGHPASSBLUR", filter->highpassBlur);
     	XML.setValue("CONFIG:INT:HIGHPASSNOISE", filter->highpassNoise);
     	XML.setValue("CONFIG:INT:HIGHPASSAMP", filter->highpassAmp);
     	XML.setValue("CONFIG:INT:SMOOTH", filter->smooth);
     	XML.setValue("CONFIG:BOOLEAN:MINIMODE", bMiniMode);
     	XML.setValue("CONFIG:BOOLEAN:TUIO",bTUIOMode);
     	XML.setValue("CONFIG:BOOLEAN:HEIGHTWIDTH", myTUIO.bHeightWidth);
     	XML.setValue("CONFIG:BOOLEAN:OSCMODE", myTUIO.bOSCMode);
     	XML.setValue("CONFIG:BOOLEAN:TCPMODE", myTUIO.bTCPMode);
     //	XML.setValue("CONFIG:NETWORK:LOCALHOST", myTUIO.localHost);
     //	XML.setValue("CONFIG:NETWORK:TUIO_PORT_OUT",myTUIO.TUIOPort);
     	XML.saveFile("config.xml");
+    }
     /************************************************
     *				Init Device
     ************************************************/
     //Init Device (camera/video)
     void ofxNCoreVision::initDevice()
+    {
     	//Pick the Source - camera or video
     	if (bcamera)
+    	{
     		//check if a firefly, ps3 camera, or other is plugged in
     		#ifdef TARGET_WIN32
     			/****PS3 - PS3 camera only****/
     		    if(ofxPS3::getDeviceCount() > 0 && PS3 == NULL)
+    			{
     				PS3 = new ofxPS3();
     				PS3->listDevices();
     				PS3->initPS3(camWidth, camHeight, camRate);
     				camWidth = PS3->getCamWidth();
     			    camHeight = PS3->getCamHeight();
     				printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, PS3->getCamWidth(), PS3->getCamHeight());
     				return;
+    			}
     			/****ffmv - firefly camera only****/
     			else if(ofxffmv::getDeviceCount() > 0 && ffmv == NULL)
+    			{
     			   ffmv = new ofxffmv();
     			   ffmv->listDevices();
     			   ffmv->initFFMV(camWidth,camHeight);
     			   printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, ffmv->getCamWidth(), ffmv->getCamHeight());
     			   camWidth = ffmv->getCamWidth();
     			   camHeight = ffmv->getCamHeight();
     			   return;
+    			}
     			else if( vidGrabber == NULL )
+    			{
     				vidGrabber = new ofVideoGrabber();
     				vidGrabber->listDevices();
     				vidGrabber->setVerbose(true);
     				vidGrabber->initGrabber(camWidth,camHeight);
     				printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, vidGrabber->width, vidGrabber->height);
     				camWidth = vidGrabber->width;
     				camHeight = vidGrabber->height;
     				return;
+    			}
     			else if( dsvl == NULL)
+    			{
     				dsvl = new ofxDSVL();
     				dsvl->initDSVL();
     				printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, dsvl->getCamWidth(), dsvl->getCamHeight());
     				camWidth = dsvl->getCamWidth();
     				camHeight = dsvl->getCamHeight();
     				return;
+    			}
     		#else
     			if( vidGrabber == NULL )
+    			{
     				vidGrabber = new ofVideoGrabber();
     				vidGrabber->listDevices();
     				vidGrabber->setVerbose(true);
     				vidGrabber->initGrabber(camWidth,camHeight);
     				printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, vidGrabber->width, vidGrabber->height);
     				camWidth = vidGrabber->width;
     				camHeight = vidGrabber->height;
     				return;
+    			}
     		#endif
+    	}
     	else
+    	{
     		if( vidPlayer == NULL )
+    		{
                 vidPlayer = new ofVideoPlayer();
                 vidPlayer->loadMovie( videoFileName );
                 vidPlayer->play();
                 vidPlayer->setLoopState(OF_LOOP_NORMAL);
     			printf("Video Mode\n\n");
     			camHeight = vidPlayer->height;
     			camWidth = vidPlayer->width;
     			return;
+            }
+    	}
+    }
     /******************************************************************************
     * The update function runs continuously. Use it to update states and variables
     *****************************************************************************/
     void ofxNCoreVision::_update(ofEventArgs &e)
+    {
     	bNewFrame = false;
     	if(bcamera) //if camera
+    	{
     		#ifdef TARGET_WIN32
     			if(PS3!=NULL)//ps3 camera
+    			{
     				bNewFrame = PS3->isFrameNew();
+    			}
     			else if(ffmv!=NULL)
+    			{
     				ffmv->grabFrame();
     				bNewFrame = true;
+    			}
     			else if(vidGrabber !=NULL)
+    			{
     				vidGrabber->grabFrame();
     				bNewFrame = vidGrabber->isFrameNew();
+    			}
     			else if(dsvl !=NULL)
+    			{
     				bNewFrame = dsvl->isFrameNew();
+    			}
     		#else
     			vidGrabber->grabFrame();
     			bNewFrame = vidGrabber->isFrameNew();
     		#endif
+    	}
     	else //if video
+    	{
     		vidPlayer->idleMovie();
     		bNewFrame = vidPlayer->isFrameNew();
+    	}
     	//if no new frame, return
     	if(!bNewFrame)
+    	{
     		return;
+    	}
     	else//else process camera frame
+    	{
     		ofBackground(0, 0, 0);
     		// Calculate FPS of Camera
     		frames++;
     		float time = ofGetElapsedTimeMillis();
     		if (time > (lastFPSlog + 1000))
+    		{
     			fps = frames;
     			frames = 0;
     			lastFPSlog = time;
     		}//End calculation
     		float beforeTime = ofGetElapsedTimeMillis();
     		if (bGPUMode)
+    		{
     			grabFrameToGPU(filter->gpuSourceTex);
     			filter->applyGPUFilters();
     			contourFinder.findContours(filter->gpuReadBackImageGS,  (MIN_BLOB_SIZE * 2) + 1, ((camWidth * camHeight) * .4) * (MAX_BLOB_SIZE * .001), maxBlobs, false);
+    		}
     		else
+    		{
     			grabFrameToCPU();
     			filter->applyCPUFilters( processedImg );
     			contourFinder.findContours(processedImg,  (MIN_BLOB_SIZE * 2) + 1, ((camWidth * camHeight) * .4) * (MAX_BLOB_SIZE * .001), maxBlobs, false);
+    		}
     		//Track found contours/blobss
     		tracker.track(&contourFinder);
     		//get DSP time
     		differenceTime = ofGetElapsedTimeMillis() - beforeTime;
     		//Dynamic Background subtraction LearRate
     		if (filter->bDynamicBG)
+    		{
     			filter->fLearnRate = backgroundLearnRate * .0001; //If there are no blobs, add the background faster.
     			if (contourFinder.nBlobs > 0) //If there ARE blobs, add the background slower.
+    			{
     				filter->fLearnRate = backgroundLearnRate * .0001;
+    			}
     		}//End Background Learning rate
     		if (bTUIOMode)
+    		{
     			//Start sending OSC
     			myTUIO.sendTUIO(&getBlobs());
+    		}
+    	}
+    }
     /************************************************
     *				Input Device Stuff
     ************************************************/
     //get pixels from camera
     void ofxNCoreVision::getPixels()
+    {
     #ifdef TARGET_WIN32
     	if(PS3!=NULL)
+    	{
     		//already grayscale
     		processedImg.setFromPixels(PS3->getPixels(), camWidth, camHeight);
+    	}
     	else if(ffmv != NULL)
+    	{
     		processedImg.setFromPixels(ffmv->fcImage[ffmv->getDeviceID()].pData, camWidth, camHeight);
+    	}
     	else if(vidGrabber != NULL )
+    	{
     		sourceImg.setFromPixels(vidGrabber->getPixels(), camWidth, camHeight);
     		//convert to grayscale
     		processedImg = sourceImg;
+    	}
     	else if(dsvl!=NULL)
+    	{
     		if(dsvl->getNumByes() != 1)
+    		{
     			//if not grayscale
     			sourceImg.setFromPixels(dsvl->getPixels(), camWidth, camHeight);
     			//convert to grayscale
     			processedImg = sourceImg;
+    		}
     		else
     		{	//if grayscale
     			processedImg.setFromPixels(dsvl->getPixels(), camWidth, camHeight);
+    		}
+    	}
     #endif
+    }
     //Grab frame from CPU
     void ofxNCoreVision::grabFrameToCPU()
+    {
     	//Set sourceImg as new camera/video frame
     	if (bcamera)
+    	{
     	    #ifdef TARGET_WIN32
     			getPixels();
      		#else
                 sourceImg.setFromPixels(vidGrabber->getPixels(), camWidth, camHeight);
      			//convert to grayscale
      			processedImg = sourceImg;
      		#endif
+    	}
     	else
+    	{
     		sourceImg.setFromPixels(vidPlayer->getPixels(), camWidth, camHeight);
     		//convert to grayscale
     		processedImg = sourceImg;
+    	}
+    }
     //Grab frame from GPU
     void ofxNCoreVision::grabFrameToGPU(GLuint target)
+    {
     	//grab the frame to a raw openGL texture
     	if (bcamera)
+    	{

Revision 198