Example #1
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);
}
Example #2
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);
}
Example #3
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);
}
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());
		}
		
	}
}