Beispiel #1
0
//--------------------------------------------------------------
void testApp::update(){
	mousePos.x = ofGetMouseX();
	mousePos.y = ofGetMouseY();
	dimensions.x = ofGetWidth();
	dimensions.y = ofGetHeight();
	
	opencl.kernel("updateParticle")->setArg(2, mousePos);
	opencl.kernel("updateParticle")->setArg(3, dimensions);
	opencl.kernel("updateParticle")->run1D(NUM_PARTICLES);
}
Beispiel #2
0
//--------------------------------------------------------------
void ofApp::update(){
	
	mousePos.x = ofGetMouseX();
	mousePos.y = ofGetMouseY();
	dimensions.x = ofGetWidth();
	dimensions.y = ofGetHeight();
	
    opencl.kernel("updateParticle")->setArg(2, mousePos);//.getPtr(), sizeof(float2));
    opencl.kernel("updateParticle")->setArg(3, dimensions);//.getPtr(), sizeof(float2) );
	glFlush();
	
	opencl.kernel("updateParticle")->run1D(NUM_PARTICLES);
}
Beispiel #3
0
//--------------------------------------------------------------
void ofApp::draw(){
	opencl.finish();

	glColor3f(1.0f, 1.0f, 1.0f);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);

	opencl.finish();

	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(2, GL_FLOAT, 0, 0);
	glDrawArrays(GL_POINTS, 0, NUM_PARTICLES);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
	
	
	glColor3f(1, 1, 1);
	string info = "fps: " + ofToString(ofGetFrameRate()) + "\nnumber of particles: " + ofToString(NUM_PARTICLES);
	ofDrawBitmapString(info, 20, 20);
}
Beispiel #4
0
//--------------------------------------------------------------
void testApp::draw(){
	glColor3f(1.0f, 1.0f, 1.0f);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]);
#ifdef USE_OPENGL_CONTEXT
	opencl.finish();
#else
	opencl.readBuffer(sizeof(Vec2) * NUM_PARTICLES, clMemPosVBO, particlesPos);
	glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, sizeof(Vec2) * NUM_PARTICLES, particlesPos);
#endif
	glEnableClientState(GL_VERTEX_ARRAY);
	glVertexPointer(2, GL_FLOAT, 0, 0);
	glDrawArrays(GL_POINTS, 0, NUM_PARTICLES);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
	
	
	glColor3f(1, 1, 1);
	string info = "fps: " + ofToString(ofGetFrameRate()) + "\nnumber of particles: " + ofToString(NUM_PARTICLES);
	ofDrawBitmapString(info, 20, 20);
}
void ofxKinectTracking::init(){
	openCL.setupFromOpenGL();
	
#ifndef NORMAL_CAMERA
	kinect = new ofxKinect();
	kinect->init();
	kinect->setVerbose(true);
	kinect->open();
	
	
	
	//The depth image
	clImage[0].initFromTexture(kinect->getDepthTextureReference(), CL_MEM_READ_ONLY, 0);	
#else
	videoGrabber.initGrabber(640, 480, true);
	clImage[0].initWithTexture(640, 480, GL_LUMINANCE, CL_MEM_READ_ONLY);
	pixels		= new unsigned char[640*480];
	
#endif
	
	//The debug image
	clImage[1].initWithTexture(640, 480, GL_RGBA);
	
	//Intialize the ants buffer
	resetBufferData();
	clAntsBuffer.initBuffer(sizeof(Ant)*NUM_ANTS, CL_MEM_READ_WRITE, ants, true);
	
	//Buffer of shared variables
	sharedVariables[0] = 0;	
	clSharedBuffer.initBuffer(sizeof(int)*1, CL_MEM_READ_WRITE, sharedVariables, true);
	
	openCL.loadProgramFromFile("../../../../../addons/ofxKinectTracking/src/KinectTracking.cl");
	
	openCL.loadKernel("preUpdate");
	openCL.loadKernel("update");
	openCL.loadKernel("postUpdate");
}
Beispiel #6
0
//--------------------------------------------------------------
void testApp::setup(){
	ofBackground(50, 50, 50);
	
	
	// dump everything to console
	ofSetLogLevel(OF_LOG_VERBOSE);
	
	
	// disable vsync (to allow >60fps)
	ofSetVerticalSync(false);
	
	
	// init grabber
	videoGrabber.initGrabber(640, 480);	
	vidWidth	= videoGrabber.getWidth();
	vidHeight	= videoGrabber.getHeight();
	

	// allocate temp buffer
	pixels		= new unsigned char[vidWidth * vidHeight * 4];
	

	// init OpenCL from OpenGL context to enable GL-CL data sharing
	openCL.setupFromOpenGL();
	
	
	// create OpenCL textures and related OpenGL textures
	clImage[0].initWithTexture(vidWidth, vidHeight, GL_RGBA);
	clImage[1].initWithTexture(vidWidth, vidHeight, GL_RGBA);
	

	// load and compile OpenCL program
	openCL.loadProgramFromFile("MSAOpenCL/ImageProcessing.cl");
	
	
	// load kernels
	openCL.loadKernel("msa_boxblur");
	openCL.loadKernel("msa_flipx");
	openCL.loadKernel("msa_flipy");
	openCL.loadKernel("msa_greyscale");
	openCL.loadKernel("msa_invert");
	openCL.loadKernel("msa_threshold");
}
Beispiel #7
0
//--------------------------------------------------------------
void testApp::draw(){
	videoGrabber.draw(0, 200);

	// make sure all OpenCL kernels have finished executing before drawing
	openCL.finish();
	
	// draw the OpenGL texture (which was mapped to the OpenCL image)
	clImage[activeImageIndex].getTexture().draw(vidWidth, 200);
	
	
	ofDrawBitmapString(    " app FPS            : " + ofToString(ofGetFrameRate(), 2)
					   + "\n capture FPS        : " + ofToString(captureFPS, 2)
					   + "\n"
					   + "\n doBlur (b)         : " + (doBlur ? "X" : "")
					   + "\n   blurAmount (1-9) : " + ofToString(blurAmount)
					   + "\n doFlipX (x)        : " + (doFlipX ? "X" : "")
					   + "\n doFlipY (y)        : " + (doFlipY ? "X" : "")
					   + "\n doGreyscale (g)    : " + (doGreyscale ? "X" : "")
					   + "\n doInvert (i)       : " + (doInvert ? "X" : "")
					   + "\n doThreshold (t)    : " + (doThreshold ? "X" : "")
					   + "\n   threshLevel ([]) : " + ofToString(threshLevel, 2)
					   , 30, 30);
}
Beispiel #8
0
//--------------------------------------------------------------
void testApp::setup(){
	ofBackground(0, 0, 0);
	ofSetLogLevel(OF_LOG_VERBOSE);
	ofSetVerticalSync(false);
	
	opencl.setupFromOpenGL();
    
    // create vbo
    glGenBuffersARB(1, &vbo);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
	glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float2) * NUM_PARTICLES, 0, GL_DYNAMIC_COPY_ARB);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

    // init host and CL buffers
    particles.initBuffer(NUM_PARTICLES);
    particlePos.initFromGLObject(vbo, NUM_PARTICLES);

    // init data
	for(int i=0; i<NUM_PARTICLES; i++) {
		Particle &p = particles[i];
		p.vel.set(0, 0);
		p.mass = ofRandom(0.5, 1);		
		particlePos[i].set(ofRandomWidth(), ofRandomHeight());
	}
    
    particles.writeToDevice();
    particlePos.writeToDevice();
	
	
	opencl.loadProgramFromFile("MSAOpenCL/Particle.cl");
	opencl.loadKernel("updateParticle");

	opencl.kernel("updateParticle")->setArg(0, particles.getCLMem());
	opencl.kernel("updateParticle")->setArg(1, particlePos.getCLMem());
	opencl.kernel("updateParticle")->setArg(2, mousePos);
	opencl.kernel("updateParticle")->setArg(3, dimensions);
	
	glPointSize(1);
}
Beispiel #9
0
//--------------------------------------------------------------
void testApp::update(){
	
	// grab new frame
	videoGrabber.update();
	
	// if there is a new frame....
	if(videoGrabber.isFrameNew()) {
		
		// RGB textures don't seem to work well. so need to copy the vidgrabber data into a RGBA texture
		int pixelIndex = 0;
		for(int i=0; i<vidWidth; i++) {
			for(int j=0; j<vidHeight; j++) {
				int indexRGB	= pixelIndex * 3;
				int indexRGBA	= pixelIndex * 4;
				
				pixels[indexRGBA  ] = videoGrabber.getPixels()[indexRGB  ];
				pixels[indexRGBA+1] = videoGrabber.getPixels()[indexRGB+1];
				pixels[indexRGBA+2] = videoGrabber.getPixels()[indexRGB+2];
				pixels[indexRGBA+3] = 255;
				pixelIndex++;
			}
		}
		

		// write the new pixel data into the OpenCL Image (and thus the OpenGL texture)
		clImage[activeImageIndex].write(pixels);
		
		
		if(doBlur) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_boxblur");
			for(int i=0; i<blurAmount; i++) {
				cl_int offset = i * i / 2 + 1;
				kernel->setArg(0, clImage[activeImageIndex].getCLMem());
				kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
				kernel->setArg(2, offset);
				kernel->run2D(vidWidth, vidHeight);
				activeImageIndex = 1 - activeImageIndex;
			}
		}
		
		if(doFlipX) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_flipx");
			kernel->setArg(0, clImage[activeImageIndex].getCLMem());
			kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
			kernel->run2D(vidWidth, vidHeight);
			activeImageIndex = 1 - activeImageIndex;
		}
		
	
		if(doFlipY) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_flipy");
			kernel->setArg(0, clImage[activeImageIndex].getCLMem());
			kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
			kernel->run2D(vidWidth, vidHeight);
			activeImageIndex = 1 - activeImageIndex;
		}
		
		if(doGreyscale) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_greyscale");
			kernel->setArg(0, clImage[activeImageIndex].getCLMem());
			kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
			kernel->run2D(vidWidth, vidHeight);
			activeImageIndex = 1 - activeImageIndex;
		}
		
		if(doInvert) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_invert");
			kernel->setArg(0, clImage[activeImageIndex].getCLMem());
			kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
			kernel->run2D(vidWidth, vidHeight);
			activeImageIndex = 1 - activeImageIndex;
		}
	
		if(doThreshold) {
			msa::OpenCLKernel *kernel = openCL.kernel("msa_threshold");
			kernel->setArg(0, clImage[activeImageIndex].getCLMem());
			kernel->setArg(1, clImage[1-activeImageIndex].getCLMem());
			kernel->setArg(2, threshLevel);
			kernel->run2D(vidWidth, vidHeight);
			activeImageIndex = 1 - activeImageIndex;
		}
		
		
		// calculate capture fps
		static float lastTime = 0;
		float nowTime = ofGetElapsedTimef();
		float timeDiff = nowTime - lastTime;
		if(timeDiff > 0 ) captureFPS = 0.9f * captureFPS + 0.1f / timeDiff;
		lastTime = nowTime;
	}
}
void ofxKinectTracking::drawDepth(int x, int y, int w, int h){
	ofSetColor(255, 255, 255);
	openCL.finish();
#ifndef NORMAL_CAMERA
	kinect->drawDepth(x,y,w,h);
#else
	clImage[0].draw(x,y,w,h);
#endif
	clImage[1].draw(x+w, y, w,h);
	
	ofSetColor(255, 0, 0);
	ofDrawBitmapString(ofToString(ofGetFrameRate(), 1), ofPoint(20,20));
	
	ofEnableAlphaBlending();
	glTranslated(0, 480*2, 0);
	
	float scale = 5000.0;
	
	{
		ofSetColor(255, 255, 255,100);
		double avg = 0;
		glBegin(GL_LINE_STRIP);
		for(int i=10;i<totalTime.size();i++){
			glVertex2d(i*3, -totalTime[i]*scale);
			avg += totalTime[i];
		}
		glEnd();
		avg /=totalTime.size()-10;
		
		ofSetColor(255, 100, 255,255);
		ofLine(0, -avg*scale, 640*2, -avg*scale);
		ofDrawBitmapString("Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10));
		
		double percentage = ((avg)/(1/30.0))*100;
		ofSetColor(255, 255, 255);
		ofDrawBitmapString("Time percentage of one frame used on openCL: "+ofToString(percentage, 2)+"%", ofPoint(5,-460));
	}
	{
		ofSetColor(255, 0, 0,150);
		double avg = 0;
		glBegin(GL_LINE_STRIP);
		for(int i=10;i<killingTime.size();i++){
			//		cout<<totalTime[i]*10000.0<<endl;
			glVertex2d(i*3, -killingTime[i]*scale);
			avg += killingTime[i];
		}
		glEnd();
		avg /=killingTime.size()-10;
		
		ofSetColor(255, 100, 0);
		ofLine(0, -avg*scale, 640*2, -avg*scale);
		ofDrawBitmapString("K Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10));
	}
	
	{
		ofSetColor(0, 255, 0,150);
		double avg = 0;
		glBegin(GL_LINE_STRIP);
		for(int i=10;i<spawningTime.size();i++){
			//		cout<<totalTime[i]*10000.0<<endl;
			glVertex2d(i*3, -spawningTime[i]*scale);
			avg += spawningTime[i];
		}
		glEnd();
		avg /=spawningTime.size()-10;
		
		ofSetColor(100, 255, 0);
		ofLine(0, -avg*scale, 640*2, -avg*scale);
		ofDrawBitmapString("S Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10));
	}
	{
		ofSetColor(0, 0, 255,150);
		double avg = 0;
		glBegin(GL_LINE_STRIP);
		for(int i=10;i<updateTime.size();i++){
			//		cout<<totalTime[i]*10000.0<<endl;
			glVertex2d(i*3, -updateTime[i]*scale);
			avg += updateTime[i];
		}
		glEnd();
		avg /=updateTime.size()-10;
		
		ofSetColor(0, 100, 255);
		ofLine(0, -avg*scale, 640*2, -avg*scale);
		ofDrawBitmapString("U Avg: "+ofToString(avg*10000, 2), ofPoint(5,-avg*scale-10));
	}
	
	
	
	
	
}
void ofxKinectTracking::update(){
	bool newFrame;
	
#ifndef NORMAL_CAMERA
	kinect->update();	
	newFrame = kinect->isFrameNew();
	
#else
	videoGrabber.update();
	newFrame = videoGrabber.isFrameNew();
	if(newFrame){
		
		
		int pixelIndex = 0;
		for(int i=0; i<640; i++) {
			for(int j=0; j<480; j++) {
				int indexRGB	= pixelIndex * 3;
				int indexL	= pixelIndex;
				
				pixels[indexL] = videoGrabber.getPixels()[indexRGB+1  ];
				pixelIndex++;
			}
		}
		
		
		// write the new pixel data into the OpenCL Image (and thus the OpenGL texture)
		clImage[0].write(pixels);
	}
	
#endif
	if(newFrame){
		cl_int2 spawnCoord = {int(ofRandom(0, 640)), int(ofRandom(0, 480))};
		if(ofRandom(0, 1) < 0.500){
			spawnCoord[0] = -1;
			spawnCoord[0] = -1;			
		}
		
		
		MSA::OpenCLKernel *preKernel = openCL.kernel("preUpdate");
		MSA::OpenCLKernel *updateKernel = openCL.kernel("update");
		MSA::OpenCLKernel *postKernel = openCL.kernel("postUpdate");
		
		
		//Prepare timetaking 
		double totalTimeTmp;
		uint64_t mbeg, mend;
		openCL.finish();
		mbeg = mach_absolute_time();
		
		//Run pre update kernel
		preKernel->setArg(0, clImage[0].getCLMem());
		preKernel->setArg(1, clAntsBuffer.getCLMem());	
		preKernel->run2D(640, 480);
		
		//Calculate time
		openCL.finish();		
		mend = mach_absolute_time();
		killingTime.push_back(machcore(mend, mbeg));
		totalTimeTmp = machcore(mend, mbeg);
		mbeg = mach_absolute_time();
		
		//Run update kernel
		size_t shared_size = (1 * 64) * sizeof(int);		
		updateKernel->setArg(0, clAntsBuffer.getCLMem());
		updateKernel->setArg(1, clSharedBuffer.getCLMem());
		updateKernel->setArg(2, spawnCoord);
		clSetKernelArg(updateKernel->getCLKernel(), 3, shared_size, NULL);
		for(int i=0;i<NUM_ITERATIONS;i++){
			updateKernel->run2D(640, 480);
		}
		
		//Calculate time
		openCL.finish();		
		mend = mach_absolute_time();
		spawningTime.push_back(machcore(mend, mbeg));
		totalTimeTmp += machcore(mend, mbeg);
		mbeg = mach_absolute_time();
		
		//Run post update kernel
		postKernel->setArg(0, clImage[0].getCLMem());
		postKernel->setArg(1, clImage[1].getCLMem());
		postKernel->setArg(2, clAntsBuffer.getCLMem());
		postKernel->setArg(3, clSharedBuffer.getCLMem());
		postKernel->setArg(4, spawnCoord);
		postKernel->run2D(640, 480);
		
		//Calculate time
		openCL.finish();		
		mend = mach_absolute_time();
		updateTime.push_back(machcore(mend, mbeg));
		totalTimeTmp += machcore(mend, mbeg);		
		totalTime.push_back(totalTimeTmp);
		if(totalTime.size() > (640*2)/3){
			totalTime.erase(totalTime.begin());
			killingTime.erase(killingTime.begin());
			spawningTime.erase(spawningTime.begin());
			updateTime.erase(updateTime.begin());
		}
		
	}
}
Beispiel #12
-1
//--------------------------------------------------------------
void testApp::setup(){
	ofBackground(0, 0, 0);
	ofSetLogLevel(OF_LOG_VERBOSE);
	ofSetVerticalSync(false);
	
#ifdef USE_OPENGL_CONTEXT
	opencl.setupFromOpenGL();
#else
	opencl.setup(CL_DEVICE_TYPE_CPU, 2);
#endif
	
	for(int i=0; i<NUM_PARTICLES; i++) {
		Particle &p = particles[i];
		p.vel.set(0, 0);
		p.mass = ofRandom(0.5, 1);
		particlesPos[i].set(ofRandomWidth(), ofRandomHeight());
	}
	
	glGenBuffersARB(1, vbo);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]);
	glBufferDataARB(GL_ARRAY_BUFFER_ARB, sizeof(float2) * NUM_PARTICLES, particlesPos, GL_DYNAMIC_COPY_ARB);
	glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
	
	
	opencl.loadProgramFromFile("MSAOpenCL/Particle.cl");
	kernelUpdate = opencl.loadKernel("updateParticle");
	
	
	clMemParticles.initBuffer(sizeof(Particle) * NUM_PARTICLES, CL_MEM_READ_WRITE, particles);
#ifdef USE_OPENGL_CONTEXT
	clMemPosVBO.initFromGLObject(vbo[0]);
#else
	clMemPosVBO.initBuffer(sizeof(Vec2) * NUM_PARTICLES, CL_MEM_READ_WRITE, particlesPos);
#endif
	
	kernelUpdate->setArg(0, clMemParticles.getCLMem());
	kernelUpdate->setArg(1, clMemPosVBO.getCLMem());
	kernelUpdate->setArg(2, mousePos);
	kernelUpdate->setArg(3, dimensions);
	
	glPointSize(1);
}