Community Core Vision (Beta)

#include "ofxTouchAdaptiveFilter.h"

		void grabFrameToCPU();

		void grabFrameToGPU(GLuint target);

		/***************************************************************

		 *						Video Settings

		 ***************************************************************/

		ofVideoGrabber 		vidGrabber;

		ofVideoPlayer 		vidPlayer;

	    int					deviceID;

		int 				camRate;

		int 				camWidth;

		int 				camHeight;

		int					minHeight;

		bool				bcamera;

        int					tmpPort;

        //---------------------------------------Blob Tracker

        ofxTouchFilter*  filter;

    	 ****************************************************************/

		ofxCvColorImage		sourceImg;

/*

* Copyright 2008 NOR_/D <http://nortd.com>

*

* * *

* The default filter.

*/

#ifndef OFX_TOUCHADAPTIVEFILTER

#define OFX_TOUCHADAPTIVEFILTER

#include "ofxTouchFilter.h"

class ofxTouchAdaptiveFilter : public ofxTouchFilter {

  public:

    void allocate( int w, int h ) {

        camWidth = w;

        camHeight = h;

        exposureStartTime = ofGetElapsedTimeMillis();

        //CPU Setup

        grayImg.allocate(camWidth, camHeight);		//Gray Image

        grayBg.allocate(camWidth, camHeight);		//Background Image

        subtractBg.allocate(camWidth, camHeight);   //Background After subtraction

        grayDiff.allocate(camWidth, camHeight);		//Difference Image between Background and Source

        highpassImg.allocate(camWidth, camHeight);  //Highpass Image

        ampImg.allocate(camWidth, camHeight);		//Amplied Image

        fiLearn.allocate(camWidth, camHeight);		//ofxFloatImage used for simple dynamic background subtraction

        //GPU Setup

        allocateGPU();

    }

    void allocateGPU(){

        glGenTextures(1, &gpuSourceTex);

        glGenTextures(1, &gpuBGTex);

        delete gpuReadBackBuffer;

        gpuReadBackBuffer = new unsigned char[camWidth*camHeight*3];

        gpuReadBackImage.allocate(camWidth, camHeight);

        gpuReadBackImageGS.allocate(camWidth, camHeight);

        glEnable(GL_TEXTURE_2D);

        glBindTexture(GL_TEXTURE_2D, gpuSourceTex);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,  camWidth, camHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);

        glBindTexture(GL_TEXTURE_2D, gpuBGTex);

        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8,  camWidth, camHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);

        glBindTexture(GL_TEXTURE_2D, 0);

        glDisable(GL_TEXTURE_2D);

        subtractFilter = new ImageFilter("filters/absSubtract.xml", camWidth, camHeight);

        subtractFilter2 = new ImageFilter("filters/subtract.xml", camWidth, camHeight);

        contrastFilter = new ImageFilter("filters/contrast.xml", camWidth, camHeight);

        gaussVFilter = new ImageFilter("filters/gaussV.xml", camWidth, camHeight);

        gaussHFilter = new ImageFilter("filters/gauss.xml", camWidth, camHeight);

        gaussVFilter2 = new ImageFilter("filters/gaussV2.xml", camWidth, camHeight);

        gaussHFilter2 = new ImageFilter("filters/gauss2.xml", camWidth, camHeight);

        threshFilter = new ImageFilter("filters/threshold.xml", camWidth, camHeight);

        copyFilter = new ImageFilter("filters/copy.xml", camWidth, camHeight);

    }

     void applyCPUFilters(CPUImageFilter& img){

        //Set Mirroring Horizontal/Vertical

        if(bVerticalMirror || bHorizontalMirror) img.mirror(bVerticalMirror, bHorizontalMirror);

        //if(!bFastMode)

        grayImg = img; //for drawing

        //Dynamic background with learn rate...eventually learnrate will have GUI sliders

        if(bDynamicBG){

            learnBackground( img, grayBg, fiLearn, fLearnRate);

        }

        //recapature the background for 2 seconds to make sure the background image is when the camera is fully loaded

        if((ofGetElapsedTimeMillis() - exposureStartTime) < CAMERA_EXPOSURE_TIME) bLearnBakground = true;

        //Capture full background

        if (bLearnBakground == true){

            learnBackground( img, grayBg, fiLearn, 1.0f);

            bLearnBakground = false;

        }

        img.absDiff(grayBg, img); //Background Subtraction

        if(bSmooth){//Smooth

            img.blur((smooth * 2) + 1); //needs to be an odd number

            //if(!bFastMode)

            subtractBg = img; //for drawing

        }

        if(bHighpass){//HighPass

            img.highpass(highpassBlur, highpassNoise);

            //if(!bFastMode)

            highpassImg = img; //for drawing

        }

        if(bAmplify){//Amplify

            img.amplify(img, highpassAmp);

            //if(!bFastMode)

            ampImg = img; //for drawing

        }

        img.threshold(threshold); //Threshold

        //if(!bFastMode)

        grayDiff = img; //for drawing

    }

    void learnBackground( ofxCvGrayscaleImage& live, ofxCvGrayscaleImage& _grayBg, ofxCvFloatImage& fLearn, float learnRate )

    {

        fLearn.addWeighted( live, learnRate);

        _grayBg = fLearn;

    }

    void applyGPUFilters(){

        if((ofGetElapsedTimeMillis() - exposureStartTime) < CAMERA_EXPOSURE_TIME) bLearnBakground = true;

        if (bLearnBakground == true){

            gpuBGTex = copyFilter->apply(gpuSourceTex, gpuBGTex);

            bLearnBakground = false;

        }

        GLuint processedTex;

        processedTex = subtractFilter->apply(gpuSourceTex, gpuBGTex);

        if(bSmooth){//Smooth

            gaussHFilter->parameters["kernel_size"]->value = (float)smooth;

            gaussVFilter->parameters["kernel_size"]->value = (float)smooth;

            processedTex = gaussHFilter->apply(processedTex);

            processedTex = gaussVFilter->apply(processedTex);

        }

        if(bHighpass){//Highpass

            gaussHFilter2->parameters["kernel_size"]->value = (float)highpassBlur;

            gaussVFilter2->parameters["kernel_size"]->value = (float)highpassBlur;

            processedTex = gaussHFilter2->apply(processedTex);

            processedTex = gaussVFilter2->apply(processedTex);

            processedTex = subtractFilter2->apply(gaussVFilter->output_texture, processedTex);

        }

        if(bAmplify){}//amplify

        threshFilter->parameters["Threshold"]->value = (float)threshold / 255.0; //threshold

        threshFilter->apply(processedTex);

        //until the rest of the pipeline is fixed well just download the preprocessing result from the gpu and use that for the blob detection

        //TODO: make this part not super slow ;)

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, threshFilter->output_buffer);

        glReadPixels(0,0,camWidth, camHeight, GL_RGB, GL_UNSIGNED_BYTE, gpuReadBackBuffer);

        gpuReadBackImage.setFromPixels(gpuReadBackBuffer, camWidth, camHeight);

        gpuReadBackImageGS = gpuReadBackImage;

        glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

    }

    void draw()

    {

        grayImg.draw(40, 30, 320, 240);

        grayDiff.draw(385, 30, 320, 240);

        fiLearn.draw(85, 392, 128, 96);

        subtractBg.draw(235, 392, 128, 96);

        highpassImg.draw(385, 392, 128, 96);

        ampImg.draw(535, 392, 128, 96);

//      ofSetColor(0x000000);

//      bigvideo.drawString("Source Image", 140, 20);

//		bigvideo.drawString("Tracked Image", 475, 20);

    }

    void drawGPU()

    {

        drawGLTexture(40, 30, 320, 240, gpuSourceTex);

        drawGLTexture(85, 392, 128, 96, gpuBGTex);

        gaussVFilter->drawOutputTexture(235, 392, 128, 96);

        subtractFilter2->drawOutputTexture(385, 392, 128, 96);

        threshFilter->drawOutputTexture(535, 392, 128, 96);

        gpuReadBackImageGS.draw(385, 30, 320, 240);

    }

};

#endif

		trackPanel->addSlider(appPtr->trackedPanel_threshold, "Threshold (a/z)", 300, 13, 0.0f, 255.0f, filter->threshold, kofxGui_Display_Int, 0);

		sPanel->addSlider(smoothPanel_smooth, "Smooth", 110, 13, 0.0f, 15.0f, filter->smooth, kofxGui_Display_Int, 0);

		hpPanel->addSlider(highpassPanel_blur, "Blur", 110, 13, 0.0f, 200.0f, filter->highpassBlur, kofxGui_Display_Int, 0);

		hpPanel->addSlider(highpassPanel_noise, "Noise", 110, 13, 0.0f, 30.0f, filter->highpassNoise, kofxGui_Display_Int, 0);

		ampPanel->addSlider(amplifyPanel_amp, "Amplify", 110, 13, 0.0f, 300.0f, filter->highpassAmp, kofxGui_Display_Int, 0);

		gui->update(appPtr->sourcePanel_cam, kofxGui_Set_Bool, &appPtr->bcamera, sizeof(bool));

		if(!bcamera){

		gui->update(appPtr->backgroundPanel_dynamic, kofxGui_Set_Bool, &appPtr->filter->bDynamicBG, sizeof(bool));

		gui->update(appPtr->smoothPanel_use, kofxGui_Set_Bool, &appPtr->filter->bSmooth, sizeof(bool));

		gui->update(appPtr->smoothPanel_smooth, kofxGui_Set_Bool, &appPtr->filter->smooth, sizeof(float));

		gui->update(appPtr->highpassPanel_use, kofxGui_Set_Bool, &appPtr->filter->bHighpass, sizeof(bool));

		gui->update(appPtr->highpassPanel_blur, kofxGui_Set_Bool, &appPtr->filter->highpassBlur, sizeof(float));

		gui->update(appPtr->highpassPanel_noise, kofxGui_Set_Bool, &appPtr->filter->highpassNoise, sizeof(float));

		gui->update(appPtr->amplifyPanel_use, kofxGui_Set_Bool, &appPtr->filter->bAmplify, sizeof(bool));

		gui->update(appPtr->amplifyPanel_amp, kofxGui_Set_Bool, &appPtr->filter->highpassAmp, sizeof(float));

		gui->update(appPtr->trackedPanel_threshold, kofxGui_Set_Bool, &appPtr->filter->threshold, sizeof(float));

						if(!bcamera){

							bcamera = true;

							vidGrabber.close();

							vidGrabber.setDeviceID(deviceID);

							vidGrabber.setVerbose(false);

							camWidth = vidGrabber.width;

							camHeight = vidGrabber.height;

							vidGrabber.initGrabber(camWidth,camHeight);

//							calibrate.setCamRes(camHeight, camWidth);

							processedImg.allocate(camWidth, camHeight); //Processed Image

							sourceImg.allocate(camWidth, camHeight);    //Source Image

							sourceImg.setUseTexture(false);

							filter->allocate(camWidth, camHeight);

						if(bcamera){

							bcamera = false;

							vidPlayer.loadMovie("test_videos/" + videoFileName);

							vidPlayer.play();

							camHeight = vidPlayer.height;

							camWidth = vidPlayer.width;

//							calibrate.setCamRes(camHeight, camWidth);

							processedImg.allocate(camWidth, camHeight); //Processed Image

							sourceImg.allocate(camWidth, camHeight);    //Source Image

							sourceImg.setUseTexture(false);

							filter->allocate(camWidth, camHeight);

						deviceID += 1;

						if(deviceID >= vidGrabber.getDeviceCount()) {deviceID = vidGrabber.getDeviceCount();}

							vidGrabber.close();

							vidGrabber.setDeviceID(deviceID);

							vidGrabber.setVerbose(true);

							vidGrabber.initGrabber(camWidth,camHeight);

							filter->exposureStartTime = ofGetElapsedTimeMillis();

						deviceID -= 1;

						if(deviceID < 0) deviceID = 0;

							vidGrabber.close();

							vidGrabber.setDeviceID(deviceID);

							vidGrabber.setVerbose(true);

							vidGrabber.initGrabber(camWidth,camHeight);

							filter->exposureStartTime = ofGetElapsedTimeMillis();

					if(*(bool*)data && bcamera)

						vidGrabber.videoSettings();

					filter->bDynamicBG = *(bool*)data;

					filter->bLearnBakground = *(bool*)data;

					filter->bHighpass = *(bool*)data;

					filter->highpassBlur = *(float*)data;

					filter->highpassNoise = *(float*)data;

					filter->bAmplify = *(bool*)data;

					filter->highpassAmp = *(float*)data;

					filter->threshold = *(float*)data;

					filter->smooth = *(float*)data;

					filter->bSmooth = *(bool*)data;

#include "gui.h"

/******************************************************************************

 * The setup function is run once to perform initializations in the application

 *****************************************************************************/

void TBetaBase::setup()

{

    //set the title to 'tbeta'

    ofSetWindowTitle("tbeta");

    //removes the 'x' button on windows which causes a crash due to a GLUT bug

#ifdef TARGET_WIN32

	HWND hwndConsole = FindWindowA(NULL, "tbeta");

	HMENU hMnu = ::GetSystemMenu(hwndConsole, FALSE);

	RemoveMenu(hMnu, SC_CLOSE, MF_BYCOMMAND);

#endif

	/********************

	 * Initalize Variables

	 *********************/

	//Intialize FPS variables

	frames		= 0;

	fps			= 0;

	lastFPSlog	= 0;

	//Calibration Booleans

	bCalibration= false;

	differenceTime = 0;

	bDrawVideo = true;

	bFullscreen = false;

	ofSetBackgroundAuto(false);

    //create filter

    if( filter == NULL ) {

        filter = new ofxTouchAdaptiveFilter();

    }

	//Load Settings from config.xml file

	loadXMLSettings();

	//Setup Window Properties

	ofSetWindowShape(winWidth,winHeight);

	ofSetFrameRate(camRate * 1.4);			//This will be based on camera fps in the future

	ofSetVerticalSync(false);	            //Set vertical sync to false for better performance?

	//Pick the Source - camera or video

    if(bcamera)

    {

        activeInput = true;

        vidGrabber.listDevices();

        vidGrabber.setDeviceID(deviceID);

        vidGrabber.setVerbose(true);

        vidGrabber.initGrabber(camWidth,camHeight);

        int grabW = vidGrabber.width;

        int grabH = vidGrabber.height;

        printf("Camera Mode\nAsked for %i by %i - actual size is %i by %i \n\n", camWidth, camHeight, grabW, grabH);

    }

    else

    {

        activeInput = true;

        vidPlayer.loadMovie("test_videos/" + videoFileName);

        vidPlayer.play();

        printf("Video Mode\n");

        camHeight = vidPlayer.height;

        camWidth = vidPlayer.width;

    }

	/*****************************************************************************************************

	 * Allocate images (needed for drawing/processing images) ----Most of These won't be needed in the end

	 ******************************************************************************************************/

	processedImg.allocate(camWidth, camHeight); //main Image that'll be processed.

	processedImg.setUseTexture(false);

	sourceImg.allocate(camWidth, camHeight);    //Source Image

	sourceImg.setUseTexture(false);				//We don't need to draw this so don't create a texture

	/******************************************************************************************************/

	//Fonts - Is there a way to dynamically change font size?

	verdana.loadFont("verdana.ttf", 8, true, true);	   //Font used for small images

	sidebarTXT.loadFont("verdana.ttf", 8, true, true);

	bigvideo.loadFont("verdana.ttf", 13, true, true);  //Font used for big images.

	//Static Images

	background.loadImage("images/background.jpg"); //Main (Temp?) Background

	gui = ofxGui::Instance(this);

	setupGUI();

    calib.setup(camWidth, camHeight, &tracker);

    filter->allocate( camWidth, camHeight );

	printf("Tbeta is setup!\n\n");

/****************************************************************

 *	Load/Save config.xml file Settings

 ****************************************************************/

void TBetaBase::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!";

	}else{

		//FAIL!

		message = "No Settings Found...";

	}

	//--------------------------------------------------------------

	//  START BINDING XML TO VARS

	//--------------------------------------------------------------

	//frameRate			= XML.getValue("CONFIG:APPLICATION:FRAMERATE",0);

	winWidth			= XML.getValue("CONFIG:WINDOW:WIDTH",0);

	winHeight			= XML.getValue("CONFIG:WINDOW:HEIGHT",0);

	minWidth			= XML.getValue("CONFIG:WINDOW:MINX",0);

	minHeight			= XML.getValue("CONFIG:WINDOW:MINY",0);

	bcamera				= XML.getValue("CONFIG:CAMERA_0:USECAMERA",0);

	deviceID			= XML.getValue("CONFIG:CAMERA_0:DEVICE",0);

	camWidth			= XML.getValue("CONFIG:CAMERA_0:WIDTH",0);

	camHeight			= XML.getValue("CONFIG:CAMERA_0:HEIGHT",0);

	camRate				= XML.getValue("CONFIG:CAMERA_0:FRAMERATE",0);

	videoFileName		= XML.getValue("CONFIG:VIDEO:FILENAME", "RearDI.m4v");

	maxBlobs			= XML.getValue("CONFIG:BLOBS:MAXNUMBER", 20);

	bShowLabels			= XML.getValue("CONFIG:BOOLEAN:LABELS",0);

	bFastMode			= XML.getValue("CONFIG:BOOLEAN:FAST",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->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);

	//GPU

	bGPUMode			= XML.getValue("CONFIG:BOOLEAN:GPU", 0);

	//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);

	//--------------------------------------------------- TODO XML NETWORK SETTINGS

	bTUIOMode			= XML.getValue("CONFIG:BOOLEAN:TUIO",0);

	tmpLocalHost		= XML.getValue("CONFIG:NETWORK:LOCALHOST", "localhost");

	tmpPort				= XML.getValue("CONFIG:NETWORK:TUIOPORT_OUT", 3333);

	myTUIO.setup(tmpLocalHost.c_str(), tmpPort); //have to convert tmpLocalHost to a const char*

	//--------------------------------------------------------------

	//  END XML SETUP

}

void TBetaBase::saveConfiguration()

{

	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:TUIO",bTUIOMode);

	XML.setValue("CONFIG:BOOLEAN:VMIRROR", filter->bVerticalMirror);

	XML.setValue("CONFIG:BOOLEAN:HMIRROR", filter->bHorizontalMirror);

	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: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:NETWORK:LOCALHOST", *myTUIO.localHost);

	//	XML.setValue("CONFIG:NETWORK:TUIO_PORT_OUT",myTUIO.TUIOPort);

	XML.saveFile("config.xml");

}

/******************************************************************************

 * The update function runs continuously. Use it to update states and variables

 *****************************************************************************/

void TBetaBase::update()

{

    bNewFrame = false;

	if(activeInput){

		if(bcamera){

			vidGrabber.grabFrame();

			bNewFrame = vidGrabber.isFrameNew();

		}

		else{

			vidPlayer.idleMovie();

			bNewFrame = vidPlayer.isFrameNew();

		}

		if (bNewFrame)

		{

			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, 1, (camWidth*camHeight)/25, maxBlobs, false);

			}

			else{

				grabFrameToCPU();

                filter->applyCPUFilters( processedImg );

				contourFinder.findContours(processedImg, 1, (camWidth*camHeight)/25, maxBlobs, false);

			}

			//Track found contours/blobss

			tracker.track(&contourFinder);

			//get DSP time

			differenceTime = ofGetElapsedTimeMillis() - beforeTime;

            //Dynamic Background subtraction LearRate

			if(filter->bDynamicBG){

				filter->fLearnRate = 0.01f; //If there are no blobs, add the background faster.

				if(contourFinder.nBlobs > 0){ //If there ARE blobs, add the background slower.

					filter->fLearnRate = 0.0003f;

				}

			}//End Background Learning rate

			if(bTUIOMode){

				//We're not using frameseq right now with OSC

				//myTUIO.update();

				//Start sending OSC

				myTUIO.sendOSC();

			}

		}

	}

}

 *				Frame Grab

//Grab frame from CPU

void TBetaBase::grabFrameToCPU(){

	//Set sourceImg as new camera/video frame

	if(bcamera)

		sourceImg.setFromPixels(vidGrabber.getPixels(), camWidth, camHeight);

	else

		sourceImg.setFromPixels(vidPlayer.getPixels(), 	camWidth, camHeight);

    //convert to grayscale

    processedImg = sourceImg;

//Grab frame from GPU

void TBetaBase::grabFrameToGPU(GLuint target){

	//grab the frame to a raw openGL texture

	if(bcamera)

	{

		glEnable(GL_TEXTURE_2D);

		//glPixelStorei(1);

		glBindTexture(GL_TEXTURE_2D, target);

		//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, camWidth, camHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, vidGrabber.getPixels());

		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, camWidth, camHeight, GL_RGB, GL_UNSIGNED_BYTE, vidGrabber.getPixels());

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

		glBindTexture(GL_TEXTURE_2D,0);

	else{

		glEnable(GL_TEXTURE_2D);

		glBindTexture(GL_TEXTURE_2D, target);

		//glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, camWidth, camHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, vidPlayer.getPixels());

		glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, camWidth, camHeight, GL_RGB, GL_UNSIGNED_BYTE, vidPlayer.getPixels());

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

		glBindTexture(GL_TEXTURE_2D,0);

/******************************************************************************

 * The draw function paints the textures onto the screen. It runs after update.

 *****************************************************************************/

void TBetaBase::draw(){

    if(showConfiguration) {

        //temporary. only auto draw if in fullscreen

        if(bNewFrame && bFullscreen == false){drawToScreen();}

        else{drawToScreen();}

        if(!bCalibration)

        gui->draw();

    }

}

        if(bGPUMode) filter->drawGPU();

        else filter->draw();

        if(bcamera)

            str2+= ofToString(vidGrabber.width, 0) + " x " + ofToString(vidGrabber.height, 0)  + "\n";

            str2+= ofToString(vidPlayer.width, 0) + " x " + ofToString(vidPlayer.height, 0)  + "\n";

        if(bcamera)

            str2+= ofToString(vidGrabber.width, 0) + " x " + ofToString(vidGrabber.height, 0)  + "\n";

            str2+= ofToString(vidPlayer.width, 0) + " x " + ofToString(vidPlayer.height, 0)  + "\n";

}

void TBetaBase::drawFingerOutlines(){

    //Find the blobs

    for(int i=0; i<contourFinder.nBlobs; i++)

    {

        //temp blob to rescale and draw on screen

        ofxTBetaCvBlob drawBlob;

        drawBlob = contourFinder.blobs[i];

        if(bDrawOutlines)

        {

            //Get the contour (points) so they can be drawn

            for( int j=0; j<contourFinder.blobs[i].nPts; j++ )

            {

                drawBlob.pts[j].x = (MAIN_WINDOW_WIDTH/camWidth)  * (drawBlob.pts[j].x);

                drawBlob.pts[j].y = (MAIN_WINDOW_HEIGHT/camHeight) * (drawBlob.pts[j].y);

            }

            //This adjusts the blob drawing for different cameras

            drawBlob.boundingRect.width  *= (MAIN_WINDOW_WIDTH/camWidth);

            drawBlob.boundingRect.height *= (MAIN_WINDOW_HEIGHT/camHeight);

            drawBlob.boundingRect.x		 *= (MAIN_WINDOW_WIDTH/camWidth);

            drawBlob.boundingRect.y		 *= (MAIN_WINDOW_HEIGHT/camHeight);

            //Draw contours (outlines) on the source image

            drawBlob.draw(40, 30);

//			ofSetColor(0x0099FF); //Make Plus Sign

//			ofRect((drawBlob.centroid.x * (MAIN_WINDOW_WIDTH/camWidth)) + 40, (drawBlob.centroid.y * (MAIN_WINDOW_HEIGHT/camHeight)) - drawBlob.boundingRect.height + 30, .5, drawBlob.boundingRect.height * 2); //Horizontal Plus

//			ofRect((drawBlob.centroid.x * (MAIN_WINDOW_WIDTH/camWidth)) - drawBlob.boundingRect.width + 40, (drawBlob.centroid.y  * (MAIN_WINDOW_HEIGHT/camHeight)) + 30, drawBlob.boundingRect.width * 2, .5); //Vertical Plus

        }

        if(bShowLabels)  //Show ID label;

        {

            float xpos = drawBlob.centroid.x * (MAIN_WINDOW_WIDTH/camWidth);

            float ypos = drawBlob.centroid.y * (MAIN_WINDOW_HEIGHT/camHeight);

            ofSetColor(0xCCFFCC);

            char idStr[1024];

            sprintf(idStr, "id: %i,(%i, %i)",drawBlob.id, drawBlob.lastCentroid.x, drawBlob.lastCentroid.y);

            verdana.drawString(idStr, xpos + 365, ypos + drawBlob.boundingRect.height/2 + 45);

        }

    }

    ofSetColor(0xFFFFFF);

}