コード例 #1
0
TuioCursor* TuioServer::addTuioCursor(float x, float y, float z) {
    sessionID++;

    int cursorID = (int)cursorList.size();
    if (((int)(cursorList.size())<=maxCursorID) && ((int)(freeCursorList.size())>0)) {
        std::list<TuioCursor*>::iterator closestCursor = freeCursorList.begin();

        for(std::list<TuioCursor*>::iterator iter = freeCursorList.begin(); iter!= freeCursorList.end(); iter++) {
            if((*iter)->getDistance(x,y,z)<(*closestCursor)->getDistance(x,y,z)) closestCursor = iter;
        }

        TuioCursor *freeCursor = (*closestCursor);
        cursorID = (*closestCursor)->getCursorID();
        freeCursorList.erase(closestCursor);
        delete freeCursor;
    } else maxCursorID = cursorID;

    TuioCursor *tcur = new TuioCursor(currentFrameTime, sessionID, cursorID, x, y, z);
    cursorList.push_back(tcur);
    updateCursor = true;

    if (verbose) {
        if (mode3d) {
            std::cout << "add cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY() << " " << tcur->getZ() << std::endl;
        } else {
            std::cout << "add cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY() << std::endl;
        }
    }

    return tcur;
}
コード例 #2
0
ファイル: tuioToSql.cpp プロジェクト: CadeLaRen/Interplay-2.0
void testApp::tuioCursorUpdated(TuioCursor & tcur){
	cout << " cursor updated: " + ofToString(tcur.getCursorID())+
	 " X: "+ofToString(tcur.getXSpeed())+
	 " Y: "+ofToString(tcur.getYSpeed())
	 << endl;
	updateDB(tcur.getCursorID(), time(NULL), tcur.getX(), tcur.getY());

	//forward the touch events to ofxMultiTouch for the InteractiveObjects
//	ofxMultiTouch.touchMoved(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #3
0
ファイル: tuioToSql.cpp プロジェクト: CadeLaRen/Interplay-2.0
void testApp::tuioCursorAdded(TuioCursor & tcur){
	cout << " cursor added: " + ofToString(tcur.getCursorID())+
	" X: "+ofToString(tcur.getX())+
	" Y: "+ofToString(tcur.getY())
	<< endl;

//	cout << ofToString(touch.id) << ofToString((int)time(NULL)) << ofToString(touch.x) << endl;
	updateDB(tcur.getCursorID(), time(NULL), tcur.getX(), tcur.getY());
	//forward the touch events to ofxMultiTouch for the InteractiveObjects
//	ofxMultiTouch.touchDown(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #4
0
void testApp::tuioCursorRemoved(TuioCursor & tcur){
	/*cout << " cursor removed: " + ofToString(tcur.getCursorID())+
	 " X: "+ofToString(tcur.getX())+
	 " Y: "+ofToString(tcur.getY())
	 << endl;*/
	
	mtActionsHub.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
	mtSliderHub.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
	
	//draggableRotatableScalableItem.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);

	//forward the touch events to ofxMultiTouch for the InteractiveObjects
	ofxMultiTouch.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #5
0
TuioCursor* TuioManager::addTuioCursor(float x, float y) {
	sessionID++;
	
	int cursorID = (int)cursorList.size();
	if ((int)(cursorList.size())<=maxCursorID) {
		std::list<TuioCursor*>::iterator closestCursor = freeCursorList.begin();
		
		for(std::list<TuioCursor*>::iterator iter = freeCursorList.begin();iter!= freeCursorList.end(); iter++) {
			if((*iter)->getDistance(x,y)<(*closestCursor)->getDistance(x,y)) closestCursor = iter;
		}
		
		TuioCursor *freeCursor = (*closestCursor);
		cursorID = (*closestCursor)->getCursorID();
		freeCursorList.erase(closestCursor);
		delete freeCursor;
	} else maxCursorID = cursorID;	
	
	TuioCursor *tcur = new TuioCursor(currentFrameTime, sessionID, cursorID, x, y);
	cursorList.push_back(tcur);
	updateCursor = true;

	for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
		(*listener)->addTuioCursor(tcur);
	
	if (verbose) 
		std::cout << "add cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY() << std::endl;

	return tcur;
}
コード例 #6
0
void TuioServer::removeTuioCursor(TuioCursor *tcur) {
	if (tcur==NULL) return;
	cursorList.remove(tcur);
	tcur->remove(currentFrameTime);
	updateCursor = true;

	if (verbose)
		std::cout << "del cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ")" << std::endl;

	if (tcur->getCursorID()==maxFingerID) {
		maxFingerID = -1;
		delete tcur;
		
		if (cursorList.size()>0) {
			std::list<TuioCursor*>::iterator clist;
			for (clist=cursorList.begin(); clist != cursorList.end(); clist++) {
				int fingerID = (*clist)->getCursorID();
				if (fingerID>maxFingerID) maxFingerID=fingerID;
			}
			
			std::list<TuioCursor*>::iterator flist;
			for (flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++) {
				TuioCursor *freeCursor = (*flist);
				if (freeCursor->getCursorID()>maxFingerID) delete freeCursor;
				else freeCursorBuffer.push_back(freeCursor);
			}
			
			freeCursorList = freeCursorBuffer;
			freeCursorBuffer.clear();
		} 
	} else if (tcur->getCursorID()<maxFingerID) freeCursorList.push_back(tcur);	
}
コード例 #7
0
ファイル: testApp.cpp プロジェクト: brolin/openFrameworks
void testApp::tuioCursorRemoved(TuioCursor & tcur){
	/*cout << " cursor removed: " + ofToString(tcur.getCursorID())+
	 " X: "+ofToString(tcur.getX())+
	 " Y: "+ofToString(tcur.getY())
	 << endl;*/
	
	//forward the touch events to ofxMultiTouch for the InteractiveObjects
	ofxMultiTouch.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #8
0
ファイル: tuioToSql.cpp プロジェクト: CadeLaRen/Interplay-2.0
void testApp::tuioCursorRemoved(TuioCursor & tcur){
//	cout << " cursor removed: " + ofToString(tcur.getCursorID())+
//	 " X: "+ofToString(tcur.getX())+
//	 " Y: "+ofToString(tcur.getY())
//	 << endl;
	updateDB(tcur.getCursorID(), time(NULL), tcur.getX(), tcur.getY());

	//forward the touch events to ofxMultiTouch for the InteractiveObjects
//	ofxMultiTouch.touchUp(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #9
0
void TuioServer::stopUntouchedMovingCursors() {

    std::list<TuioCursor*> untouched;
    for (std::list<TuioCursor*>::iterator tuioCursor = cursorList.begin(); tuioCursor!=cursorList.end(); tuioCursor++) {
        TuioCursor *tcur = (*tuioCursor);
        if ((tcur->getTuioTime()!=currentFrameTime) && (tcur->isMoving())) {
            tcur->stop(currentFrameTime);
            updateCursor = true;
            if (verbose) {
                if (mode3d) {
                    std::cout << "set cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY() << " " << tcur->getZ()
                              << " " << tcur->getXSpeed() << " " << tcur->getYSpeed()<< " " << tcur->getZSpeed()<< " " << tcur->getMotionAccel() << " " << std::endl;
                } else {
                    std::cout << "set cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY()
                              << " " << tcur->getXSpeed() << " " << tcur->getYSpeed()<< " " << tcur->getMotionAccel() << " " << std::endl;
                }
            }
        }
    }
}
コード例 #10
0
void testApp::tuioCursorUpdated(TuioCursor & tcur){
	/*cout << " cursor updated: " + ofToString(tcur.getCursorID())+
	 " X: "+ofToString(tcur.getXSpeed())+
	 " Y: "+ofToString(tcur.getYSpeed())
	 << endl;*/
	
	ofxMultiTouchCustomDataSF multiTouchCustomData;
	multiTouchCustomData.sessionID = tcur.getSessionID();
	
	mtActionsHub.touchMoved(tcur.getX(), tcur.getY(), tcur.getCursorID(), &multiTouchCustomData);
	mtSliderHub.touchMoved(tcur.getX(), tcur.getY(), tcur.getCursorID(), &multiTouchCustomData);
	/*
	draggableRotatableScalableItem.touchMoved(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
	if(draggableRotatableScalableItem.ownTouchCursor(tcur.getSessionID())) {
		return;
	}
	*/
	//forward the touch events to ofxMultiTouch for the InteractiveObjects
	ofxMultiTouch.touchMoved(tcur.getX(), tcur.getY(), tcur.getCursorID(), NULL);
}
コード例 #11
0
void TuioKinect::updateTuio() {
	TuioTime frameTime = TuioTime::getSessionTime();
	tuioServer->initFrame(frameTime);

	std::vector<ofxCvBlob>::iterator blob;
//	printf("Blobs: %d\n", contourFinder.blobs.size());
	for (blob=contourFinder.blobs.begin(); blob!= contourFinder.blobs.end(); blob++) {
		float xpos = (*blob).centroid.x;
		float ypos = (*blob).centroid.y;

		TuioPoint tp(xpos/kinect.width,ypos/kinect.height);

		//if ((tp.getY() > 0.8) && (tp.getX()>0.25) && (tp.getX()<0.75)) continue;

		TuioCursor *tcur = tuioServer->getClosestTuioCursor(tp.getX(),tp.getY());
		if ((tcur==NULL) || (tcur->getDistance(&tp)>0.2)) {
			tcur = tuioServer->addTuioCursor(tp.getX(), tp.getY());
			updateKalman(tcur->getCursorID(),tcur);

		} else {
			TuioPoint kp = updateKalman(tcur->getCursorID(),tp);
			tuioServer->updateTuioCursor(tcur, kp.getX(), kp.getY());

		}
	}

	tuioServer->stopUntouchedMovingCursors();

	std::list<TuioCursor*> dead_cursor_list = tuioServer->getUntouchedCursors();
	std::list<TuioCursor*>::iterator dead_cursor;
	for (dead_cursor=dead_cursor_list.begin(); dead_cursor!= dead_cursor_list.end(); dead_cursor++) {
		clearKalman((*dead_cursor)->getCursorID());

	}

	tuioServer->removeUntouchedStoppedCursors();
	tuioServer->commitFrame();
}
コード例 #12
0
ファイル: ofxTuioClient.cpp プロジェクト: lzsngr/Paracosm
void ofxTuioClient::drawCursors(){
    std::list<TuioCursor*> cursorList = client->getTuioCursors();
	std::list<TuioCursor*>::iterator tit;
	client->lockCursorList();
	for (tit=cursorList.begin(); tit != cursorList.end(); tit++) {
		TuioCursor * cur = (*tit);
		//if(tcur!=0){
			//TuioCursor cur = *tcur;
			glColor3f(0.0,0.0,0.0);
			ofEllipse(cur->getX()*ofGetWidth(), cur->getY()*ofGetHeight(), 10.0, 10.0);
			string str = "SessionId: "+ofToString((int)(cur->getSessionID()));
			ofDrawBitmapString(str, cur->getX()*ofGetWidth()-10.0, cur->getY()*ofGetHeight()+25.0);
			str = "CursorId: "+ofToString((int)(cur->getCursorID()));
			ofDrawBitmapString(str, cur->getX()*ofGetWidth()-10.0, cur->getY()*ofGetHeight()+40.0);
		//}
	}
	client->unlockCursorList();
}
コード例 #13
0
ファイル: TuioManager.cpp プロジェクト: mkalten/reacTIVision
void TuioManager::removeTuioCursor(TuioCursor *tcur) {
	if (tcur==NULL) return;

	if (verbose && tcur->getTuioState()!=TUIO_ADDED)
		std::cout << "del cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ")" << std::endl;
	
	cursorList.remove(tcur);
	tcur->remove(currentFrameTime);
	updateCursor = true;

	for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
		(*listener)->removeTuioCursor(tcur);

	if (tcur->getCursorID()==maxCursorID) {
		maxCursorID = -1;
		delete tcur;
		
		if (cursorList.size()>0) {
			std::list<TuioCursor*>::iterator clist;
			for (clist=cursorList.begin(); clist != cursorList.end(); clist++) {
				int cursorID = (*clist)->getCursorID();
				if (cursorID>maxCursorID) maxCursorID=cursorID;
			}
			
			freeCursorBuffer.clear();
			for (std::list<TuioCursor*>::iterator flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++) {
				TuioCursor *freeCursor = (*flist);
				if (freeCursor->getCursorID()>maxCursorID) delete freeCursor;
				else freeCursorBuffer.push_back(freeCursor);
			}
			
			freeCursorList = freeCursorBuffer;

		} else {
			for (std::list<TuioCursor*>::iterator flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++) {
				TuioCursor *freeCursor = (*flist);
				delete freeCursor;
			}
			freeCursorList.clear();
		}
	} else if (tcur->getCursorID()<maxCursorID) {
		freeCursorList.push_back(tcur);	
	}
}
コード例 #14
0
void TUIOInputModule::removeTuioCursor(TuioCursor *tcur) {
	std::vector<TouchInfo> touches;	
	std::list<TuioCursor*> cursorList = tuioClient->getTuioCursors();
	tuioClient->lockCursorList();
	for (std::list<TuioCursor*>::iterator iter = cursorList.begin(); iter!=cursorList.end(); iter++) {
			TuioCursor *tuioCursor = (*iter);	
			TouchInfo touch;	
			touch.position.x = tuioCursor->getX();
			touch.position.y = tuioCursor->getY();
			touch.id= tuioCursor->getCursorID();			
			touches.push_back(touch);
	}
	tuioClient->unlockCursorList();	
	TUIOEvent event;
	event.type = InputEvent::EVENT_TOUCHES_ENDED;
	event.touches = touches;
	
	CoreServices::getInstance()->getCore()->lockMutex(eventMutex);
	events.push_back(event);					
	CoreServices::getInstance()->getCore()->unlockMutex(eventMutex);
}
コード例 #15
0
ファイル: TuioDemo.cpp プロジェクト: crunchytech/TUIO11_CPP
void TuioDemo::drawObjects() {
	glClear(GL_COLOR_BUFFER_BIT);
	char id[3];
	
	// draw the cursors
	std::list<TuioCursor*> cursorList = tuioClient->getTuioCursors();
	tuioClient->lockCursorList();
	for (std::list<TuioCursor*>::iterator iter = cursorList.begin(); iter!=cursorList.end(); iter++) {
		TuioCursor *tuioCursor = (*iter);
		std::list<TuioPoint> path = tuioCursor->getPath();
		if (path.size()>0) {
			
			TuioPoint last_point = path.front();
			glBegin(GL_LINES);
			glColor3f(0.0, 0.0, 1.0);
			
			for (std::list<TuioPoint>::iterator point = path.begin(); point!=path.end(); point++) {
				glVertex3f(last_point.getScreenX(width), last_point.getScreenY(height), 0.0f);
				glVertex3f(point->getScreenX(width), point->getScreenY(height), 0.0f);
				last_point.update(point->getX(),point->getY());
			} glEnd();
			
			// draw the finger tip
			glColor3f(0.75, 0.75, 0.75);
			glPushMatrix();
			glTranslatef(last_point.getScreenX(width), last_point.getScreenY(height), 0.0);
			glBegin(GL_TRIANGLE_FAN);
			for(double a = 0.0f; a <= 2*M_PI; a += 0.2f) {
				glVertex2d(cos(a) * height/100.0f, sin(a) * height/100.0f);
			} glEnd();
			glPopMatrix();
			
			glColor3f(0.0, 0.0, 0.0);
			glRasterPos2f(tuioCursor->getScreenX(width),tuioCursor->getScreenY(height));
			sprintf(id,"%d",tuioCursor->getCursorID());
			drawString(id);
		}
	}
	tuioClient->unlockCursorList();
	
	// draw the objects
	std::list<TuioObject*> objectList = tuioClient->getTuioObjects();
	tuioClient->lockObjectList();
	for (std::list<TuioObject*>::iterator iter = objectList.begin(); iter!=objectList.end(); iter++) {
		TuioObject *tuioObject = (*iter);
		int pos_size = height/25.0f;
		int neg_size = -1*pos_size;
		float xpos  = tuioObject->getScreenX(width);
		float ypos  = tuioObject->getScreenY(height);
		float angle = tuioObject->getAngleDegrees();
		
		glColor3f(0.0, 0.0, 0.0);
		glPushMatrix();
		glTranslatef(xpos, ypos, 0.0);
		glRotatef(angle, 0.0, 0.0, 1.0);
		glBegin(GL_QUADS);
		glVertex2f(neg_size, neg_size);
		glVertex2f(neg_size, pos_size);
		glVertex2f(pos_size, pos_size);
		glVertex2f(pos_size, neg_size);
		glEnd();
		glPopMatrix();
		
		glColor3f(1.0, 1.0, 1.0);
		glRasterPos2f(xpos,ypos+5);
		sprintf(id,"%d",tuioObject->getSymbolID());
		drawString(id);
	}
	tuioClient->unlockObjectList();
	
	// draw the blobs
	std::list<TuioBlob*> blobList = tuioClient->getTuioBlobs();
	tuioClient->lockBlobList();
	for (std::list<TuioBlob*>::iterator iter = blobList.begin(); iter!=blobList.end(); iter++) {
		TuioBlob *tuioBlob = (*iter);
		float blob_width = tuioBlob->getScreenWidth(width)/2;
		float blob_height = tuioBlob->getScreenHeight(height)/2;
		float xpos  = tuioBlob->getScreenX(width);
		float ypos  = tuioBlob->getScreenY(height);
		float angle = tuioBlob->getAngleDegrees();
		
		glColor3f(0.25, 0.25, 0.25);
		glPushMatrix();
		glTranslatef(xpos, ypos, 0.0);
		glRotatef(angle, 0.0, 0.0, 1.0);
		
		/*glBegin(GL_QUADS);
		 glVertex2f(blob_width/-2, blob_height/-2);
		 glVertex2f(blob_width/-2, blob_height/2);
		 glVertex2f(blob_width/2, blob_height/2);
		 glVertex2f(blob_width/2, blob_height/-2);
		 glEnd();*/
		
		glBegin(GL_TRIANGLE_FAN);
		for(double a = 0.0f; a <= 2*M_PI; a += 0.2f) {
			glVertex2d(cos(a) * blob_width, sin(a) * blob_height);
		} glEnd();
		
		glPopMatrix();
		
		glColor3f(1.0, 1.0, 1.0);
		glRasterPos2f(xpos,ypos+5);
		sprintf(id,"%d",tuioBlob->getBlobID());
		drawString(id);
	}
	tuioClient->unlockBlobList();
	
	SDL_GL_SwapBuffers();
}
コード例 #16
0
ファイル: SimpleSimulator.cpp プロジェクト: footas/TUIO11_CPP
void SimpleSimulator::drawFrame() {

	if(!running) return;
	glClear(GL_COLOR_BUFFER_BIT);
	char id[3];

	// draw the cursors
	std::list<TuioCursor*> cursorList = tuioServer->getTuioCursors();
	for (std::list<TuioCursor*>::iterator iter = cursorList.begin(); iter!=cursorList.end(); iter++) {
		TuioCursor *tcur = (*iter);
		std::list<TuioPoint> path = tcur->getPath();
		if (path.size()>0) {

			TuioPoint last_point = path.front();
			glBegin(GL_LINES);
			glColor3f(0.0, 0.0, 1.0);

			for (std::list<TuioPoint>::iterator point = path.begin(); point!=path.end(); point++) {
				glVertex3f(last_point.getScreenX(width), last_point.getScreenY(height), 0.0f);
				glVertex3f(point->getScreenX(width), point->getScreenY(height), 0.0f);
				last_point.update(point->getX(),point->getY());
			}
			glEnd();

			// draw the finger tip
			glColor3f(0.75, 0.75, 0.75);
			std::list<TuioCursor*>::iterator joint = std::find( jointCursorList.begin(), jointCursorList.end(), tcur );
			if( joint != jointCursorList.end() ) {
				glColor3f(0.5, 0.5, 0.5);
			}
			glPushMatrix();
			glTranslatef(last_point.getScreenX(width), last_point.getScreenY(height), 0.0f);
			glBegin(GL_TRIANGLE_FAN);
			for(double a = 0.0f; a <= 2*M_PI; a += 0.2f) {
				glVertex2d(cos(a) * height/100.0f, sin(a) * height/100.0f);
			}
			glEnd();
			glPopMatrix();

			glColor3f(0.0, 0.0, 0.0);
			glRasterPos2f(tcur->getScreenX(width),tcur->getScreenY(height));
			sprintf(id,"%d",tcur->getCursorID());
			drawString(id);
		}
	}

	if (help) {
		glColor3f(0.0, 0.0, 1.0);
		glRasterPos2f(10,20);
		drawString("h - toggle help display");
		glRasterPos2f(10,35);
		if (verbose) drawString("v - disable verbose mode");
		else drawString("v - enable verbose mode");
		glRasterPos2f(10,50);
		drawString("r - reset session");
		glRasterPos2f(10,65);
		if (tuioServer->fullUpdateEnabled()) drawString("f - disable full update");
		else drawString("f - enable full update");
		glRasterPos2f(10,80);
		if (tuioServer->periodicMessagesEnabled()) drawString("p - disable periodic messages");
		else drawString("p - enable periodic messages");
		glRasterPos2f(10,95);
		drawString("SHIFT click - create persistent cursor");
		glRasterPos2f(10,110);
		drawString("CTRL click - add to cursor group");
		glRasterPos2f(10,125);
		if (fullscreen) drawString("F1 - exit fullscreen mode");
		else drawString("F1 - enter fullscreen mode");
		glRasterPos2f(10,140);
		drawString("ESC - Quit");
	}

	SDL_GL_SwapBuffers();
}
コード例 #17
0
ファイル: TuioKinect.cpp プロジェクト: 6301158/KinectHacks
//--------------------------------------------------------------
void TuioKinect::update()
{

	ofBackground(10, 10, 10);
	
	//Kinect + Feeds updating
	kinect.update();

	grayImage.setFromPixels(kinect.getDepthPixels(), kinect.width, kinect.height);
	grayImage.mirror(false, true);
	
	unsigned char * pix = grayImage.getPixels();
	int numPixels = grayImage.getWidth() * grayImage.getHeight()-1;
	
	depthImage.setFromPixels(pix, kinect.width, kinect.height);
	depthImage.flagImageChanged();
	
	colorImage.setFromPixels(kinect.getPixels(), kinect.width, kinect.height);
	colorImage.mirror(false, true);
	colorImage.convertToGrayscalePlanarImage(redImage, 0);
	
	for(int i = numPixels; i > 0 ; i--){
		if( pix[i] > nearThreshold && pix[i] < farThreshold ){
			pix[i] = 255;
		}else{
			pix[i] = 0;
		}
	}
	
	//update the cv image
	grayImage.flagImageChanged();
	
	unsigned char * red = redImage.getPixels();
	numPixels = redImage.getWidth() * redImage.getHeight();
	//
	contourFinder.findContours(grayImage, 900, (kinect.width*kinect.height)/8, 20, false);
	
	TuioTime frameTime = TuioTime::getSessionTime();
	tuioServer->initFrame(frameTime);
	
	int numBlobs = contourFinder.blobs.size() ;
	int count = 0 ; 
	
	if ( numBlobs == 0 ) 
		holdingLength = 0 ;
	
	//detect all blobs
	std::vector<ofxCvBlob>::iterator blob;
	for (blob=contourFinder.blobs.begin(); blob!= contourFinder.blobs.end(); blob++) 
	{
		float xpos = (*blob).centroid.x;
		float ypos = (*blob).centroid.y;
		
		TuioPoint tp(xpos/kinect.width,ypos/kinect.height);
		
		TuioCursor *tcur = tuioServer->getClosestTuioCursor(tp.getX(),tp.getY());
		
		//Adjust here to change minumum distance for new points
		if ((tcur==NULL) || (tcur->getDistance(&tp)>0.1)) { 
			tcur = tuioServer->addTuioCursor(tp.getX(), tp.getY());
			updateKalman(tcur->getCursorID(),tcur);
		} else {
			TuioPoint kp = updateKalman(tcur->getCursorID(),tp);
			tuioServer->updateTuioCursor(tcur, kp.getX(), kp.getY());
		}
		
		xpos = tp.getX() * ofGetWidth() ; 
		ypos = tp.getY() * ofGetHeight() ; 
		
		if ( numBlobs < 3 )
		{
			kCursors[count].x = xpos ; 
			kCursors[count].y = ypos ; 
		}
		count++ ;
	}
	
	float strength = 5.0f;
	float damping  = 0.5f;
	
	if ( numBlobs == 2 ) 
	{
		if ( holdingLength < 40 ) 
			holdingLength++ ;

		float holdingRatio = 0.05f + (float)holdingLength/40.0f ;
		float minDis   = 100.0f;
		
		ofPoint c1 = kCursors[1] ; 
		ofPoint c0 = kCursors[0] ; 
		
		for(int i=0; i< customParticles.size() ; i++) 
		{	
			CustomParticle& p = customParticles[i] ; 
			if ( i % 2 == 0 ) 
			{
				p.addAttractionPoint( c0.x, c0.y, (float)holdingLength*1.05 * strength, minDis);
			}
			else 
			{
				p.addAttractionPoint( c1.x, c1.y, (float)holdingLength*1.05 * strength, minDis);
			}

			p.addDamping(damping, damping);
		}
	
	}

	//remove non moving cursors
	tuioServer->stopUntouchedMovingCursors();
	
	std::list<TuioCursor*> dead_cursor_list = tuioServer->getUntouchedCursors();
	std::list<TuioCursor*>::iterator dead_cursor;
	for (dead_cursor=dead_cursor_list.begin(); dead_cursor!= dead_cursor_list.end(); dead_cursor++) 
	{
		clearKalman((*dead_cursor)->getCursorID());
	}
	
	tuioServer->removeUntouchedStoppedCursors();
	tuioServer->commitFrame();

	box2d.update() ; 
}
コード例 #18
0
ファイル: TuioClient.cpp プロジェクト: MartinHN/PdPulpito
void TuioClient::oscMessageReceived (const OSCMessage& message)  {
    
    
    
    if( message.getAddressPattern() == "/tuio/2Dcur" ) {
        String cmd;
        cmd = message[0].getString();
        
        if (cmd == "set") {
            
            int32 s_id;
            float xpos, ypos, xspeed, yspeed, maccel;
            s_id=message[1].getInt32();
            xpos=message[2].getFloat32();
            ypos=message[3].getFloat32();
            xspeed =message[4].getFloat32();
            yspeed=message[5].getFloat32();
            maccel=message[6].getFloat32();
            
            
            std::list<TuioCursor*>::iterator tcur;
            for (tcur=cursorList.begin(); tcur!= cursorList.end(); tcur++)
                if((*tcur)->getSessionID()==(long)s_id) break;
            
            if (tcur==cursorList.end()) {
                
                TuioCursor *addCursor = new TuioCursor((long)s_id,-1,xpos,ypos);
                frameCursors.push_back(addCursor);
                
            } else if ( ((*tcur)->getX()!=xpos) || ((*tcur)->getY()!=ypos) || ((*tcur)->getXSpeed()!=xspeed) || ((*tcur)->getYSpeed()!=yspeed) || ((*tcur)->getMotionAccel()!=maccel) ) {
                
                int id = (*tcur)->getCursorID();
                TuioCursor *updateCursor = new TuioCursor((long)s_id,id,xpos,ypos);
                updateCursor->update(xpos,ypos,xspeed,yspeed,maccel);
                frameCursors.push_back(updateCursor);
                
                
                
                
            }
            
            
            
            
        } else if (cmd=="alive") {
            
            aliveCursorList.clear();
            for(int i = 1; i < message.size() ; i++) {
                aliveCursorList.push_back(message[i].getInt32());
            }
            

        } else if( cmd== "fseq"  ){
            
            int32 fseq;
            fseq = message[1].getInt32();
            bool lateFrame = false;
            if (fseq>0) {
                if (fseq>currentFrame) currentTime = TuioTime::getSessionTime();
                if ((fseq>=currentFrame) || ((currentFrame-fseq)>100)) currentFrame = fseq;
                else lateFrame = true;
            }  else if ((TuioTime::getSessionTime().getTotalMilliseconds()-currentTime.getTotalMilliseconds())>100) {
                currentTime = TuioTime::getSessionTime();
            }
			
            if (!lateFrame) {
                
                //                lockCursorList();
                // find the removed cursors first
                for (std::list<TuioCursor*>::iterator tcur=cursorList.begin(); tcur != cursorList.end(); tcur++) {
                    std::list<long>::iterator iter = find(aliveCursorList.begin(), aliveCursorList.end(), (*tcur)->getSessionID());
                    
                    if (iter == aliveCursorList.end()) {
                        (*tcur)->remove(currentTime);
                        frameCursors.push_back(*tcur);
                    }
                }
                //                unlockCursorList();
                
                for (std::list<TuioCursor*>::iterator iter=frameCursors.begin(); iter != frameCursors.end(); iter++) {
                    TuioCursor *tcur = (*iter);
                    
                    int c_id = -1;
                    TuioCursor *frameCursor = NULL;
                    switch (tcur->getTuioState()) {
                        case TUIO_REMOVED:
                            frameCursor = tcur;
                            frameCursor->remove(currentTime);
                            
                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
                                (*listener)->removeTuioCursor(frameCursor);
                            
                            //                            lockCursorList();
                            for (std::list<TuioCursor*>::iterator delcur=cursorList.begin(); delcur!=cursorList.end(); delcur++) {
                                if((*delcur)->getSessionID()==frameCursor->getSessionID()) {
                                    cursorList.erase(delcur);
                                    break;
                                }
                            }
                            
                            if (frameCursor->getCursorID()==maxCursorID) {
                                maxCursorID = -1;
                                delete frameCursor;
                                
                                if (cursorList.size()>0) {
                                    std::list<TuioCursor*>::iterator clist;
                                    for (clist=cursorList.begin(); clist != cursorList.end(); clist++) {
                                        c_id = (*clist)->getCursorID();
                                        if (c_id>maxCursorID) maxCursorID=c_id;
                                    }
                                    
                                    freeCursorBuffer.clear();
                                    for (std::list<TuioCursor*>::iterator flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++) {
                                        TuioCursor *freeCursor = (*flist);
                                        if (freeCursor->getCursorID()>maxCursorID) delete freeCursor;
                                        else freeCursorBuffer.push_back(freeCursor);
                                    }
                                    freeCursorList = freeCursorBuffer;
                                    
                                } else {
                                    for (std::list<TuioCursor*>::iterator flist=freeCursorList.begin(); flist != freeCursorList.end(); flist++) {
                                        TuioCursor *freeCursor = (*flist);
                                        delete freeCursor;
                                    }
                                    freeCursorList.clear();
                                }
                            } else if (frameCursor->getCursorID()<maxCursorID) {
                                freeCursorList.push_back(frameCursor);
                            }
                            
                            //                            unlockCursorList();
                            break;
                        case TUIO_ADDED:
                            
                            //                            lockCursorList();
                            c_id = (int)cursorList.size();
                            if (((int)(cursorList.size())<=maxCursorID) && ((int)(freeCursorList.size())>0)) {
                                std::list<TuioCursor*>::iterator closestCursor = freeCursorList.begin();
                                
                                for(std::list<TuioCursor*>::iterator iter = freeCursorList.begin();iter!= freeCursorList.end(); iter++) {
                                    if((*iter)->getDistance(tcur)<(*closestCursor)->getDistance(tcur)) closestCursor = iter;
                                }
                                
                                TuioCursor *freeCursor = (*closestCursor);
                                c_id = freeCursor->getCursorID();
                                freeCursorList.erase(closestCursor);
                                delete freeCursor;
                            } else maxCursorID = c_id;
                            
                            frameCursor = new TuioCursor(currentTime,tcur->getSessionID(),c_id,tcur->getX(),tcur->getY());
                            cursorList.push_back(frameCursor);
                            
                            delete tcur;
                            //                            unlockCursorList();
                            
                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++){
                                (*listener)->addTuioCursor(frameCursor);
                            }
                            
                            break;
                        default:
                            
                            //                            lockCursorList();
                            std::list<TuioCursor*>::iterator iter;
                            for (iter=cursorList.begin(); iter != cursorList.end(); iter++) {
                                if((*iter)->getSessionID()==tcur->getSessionID()) {
                                    frameCursor = (*iter);
                                    break;
                                }
                            }
                            
                            if ( (tcur->getX()!=frameCursor->getX() && tcur->getXSpeed()==0) || (tcur->getY()!=frameCursor->getY() && tcur->getYSpeed()==0) )
                                frameCursor->update(currentTime,tcur->getX(),tcur->getY());
                            else
                                frameCursor->update(currentTime,tcur->getX(),tcur->getY(),tcur->getXSpeed(),tcur->getYSpeed(),tcur->getMotionAccel());
                            
                            delete tcur;
                            //                            unlockCursorList();
                            
                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
                                (*listener)->updateTuioCursor(frameCursor);
                    }
                }
                
                for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
                    (*listener)->refresh(currentTime);
                
            } else {
                for (std::list<TuioCursor*>::iterator iter=frameCursors.begin(); iter != frameCursors.end(); iter++) {
                    TuioCursor *tcur = (*iter);
                    delete tcur;
                }
            }
            
            frameCursors.clear();
        }
    }
    else if( message.getAddressPattern()== "/tuio/2Dobj" ){
        
        //        String cmd = message[0].getString();
        //
        //        if (cmd=="set") {
        //
        //            int32 s_id, c_id;
        //            float xpos, ypos, angle, xspeed, yspeed, rspeed, maccel, raccel;
        //            s_id=message[1].getInt32();
        //            c_id=message[2].getInt32();
        //            xpos=message[3].getFloat32();
        //            ypos=message[4].getFloat32();
        //            angle=message[5].getFloat32();
        //            xspeed =message[6].getFloat32();
        //            yspeed=message[7].getFloat32();
        //            rspeed=message[8].getFloat32();
        //            maccel=message[9].getFloat32();
        //            raccel=message[10].getFloat32();
        //
        //            lockObjectList();
        //            std::list<TuioObject*>::iterator tobj;
        //            for (tobj=objectList.begin(); tobj!= objectList.end(); tobj++)
        //                if((*tobj)->getSessionID()==(long)s_id) break;
        //
        //            if (tobj == objectList.end()) {
        //
        //                TuioObject *addObject = new TuioObject((long)s_id,(int)c_id,xpos,ypos,angle);
        //                frameObjects.push_back(addObject);
        //
        //            } else if ( ((*tobj)->getX()!=xpos) || ((*tobj)->getY()!=ypos) || ((*tobj)->getAngle()!=angle) || ((*tobj)->getXSpeed()!=xspeed) || ((*tobj)->getYSpeed()!=yspeed) || ((*tobj)->getRotationSpeed()!=rspeed) || ((*tobj)->getMotionAccel()!=maccel) || ((*tobj)->getRotationAccel()!=raccel) ) {
        //
        //                TuioObject *updateObject = new TuioObject((long)s_id,(*tobj)->getSymbolID(),xpos,ypos,angle);
        //                updateObject->update(xpos,ypos,angle,xspeed,yspeed,rspeed,maccel,raccel);
        //                frameObjects.push_back(updateObject);
        //
        //            }
        //            unlockObjectList();
        //
        //        }
        //        else if (cmd=="alive") {
        //
        //            aliveObjectList.clear();
        //            for(int i = 1 ; i < message.size() ; i++){
        //                aliveObjectList.push_back(message[i].getInt32());
        //            }
        //
        //        } else if (cmd == "fseq") {
        //
        //            int32 fseq;
        //            fseq = message[1].getInt32();
        //            bool lateFrame = false;
        //            if (fseq>0) {
        //                if (fseq>currentFrame) currentTime = TuioTime::getSessionTime();
        //                if ((fseq>=currentFrame) || ((currentFrame-fseq)>100)) currentFrame = fseq;
        //                else lateFrame = true;
        //            } else if ((TuioTime::getSessionTime().getTotalMilliseconds()-currentTime.getTotalMilliseconds())>100) {
        //                currentTime = TuioTime::getSessionTime();
        //            }
        //
        //            if (!lateFrame) {
        //
        //                lockObjectList();
        //                //find the removed objects first
        //                for (std::list<TuioObject*>::iterator tobj=objectList.begin(); tobj != objectList.end(); tobj++) {
        //                    std::list<long>::iterator iter = find(aliveObjectList.begin(), aliveObjectList.end(), (*tobj)->getSessionID());
        //                    if (iter == aliveObjectList.end()) {
        //                        (*tobj)->remove(currentTime);
        //                        frameObjects.push_back(*tobj);
        //                    }
        //                }
        //                unlockObjectList();
        //
        //                for (std::list<TuioObject*>::iterator iter=frameObjects.begin(); iter != frameObjects.end(); iter++) {
        //                    TuioObject *tobj = (*iter);
        //
        //                    TuioObject *frameObject = NULL;
        //                    switch (tobj->getTuioState()) {
        //                        case TUIO_REMOVED:
        //                            frameObject = tobj;
        //                            frameObject->remove(currentTime);
        //
        //                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
        //                                (*listener)->removeTuioObject(frameObject);
        //
        //                            lockObjectList();
        //                            for (std::list<TuioObject*>::iterator delobj=objectList.begin(); delobj!=objectList.end(); delobj++) {
        //                                if((*delobj)->getSessionID()==frameObject->getSessionID()) {
        //                                    objectList.erase(delobj);
        //                                    break;
        //                                }
        //                            }
        //                            unlockObjectList();
        //                            break;
        //                        case TUIO_ADDED:
        //
        //                            lockObjectList();
        //                            frameObject = new TuioObject(currentTime,tobj->getSessionID(),tobj->getSymbolID(),tobj->getX(),tobj->getY(),tobj->getAngle());
        //                            objectList.push_back(frameObject);
        //                            unlockObjectList();
        //
        //                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
        //                                (*listener)->addTuioObject(frameObject);
        //
        //                            break;
        //                        default:
        //
        //                            lockObjectList();
        //                            std::list<TuioObject*>::iterator iter;
        //                            for (iter=objectList.begin(); iter != objectList.end(); iter++) {
        //                                if((*iter)->getSessionID()==tobj->getSessionID()) {
        //                                    frameObject = (*iter);
        //                                    break;
        //                                }
        //                            }
        //                            if(iter==objectList.end()) break;
        //
        //                            if ( (tobj->getX()!=frameObject->getX() && tobj->getXSpeed()==0) || (tobj->getY()!=frameObject->getY() && tobj->getYSpeed()==0) )
        //                                frameObject->update(currentTime,tobj->getX(),tobj->getY(),tobj->getAngle());
        //                            else
        //                                frameObject->update(currentTime,tobj->getX(),tobj->getY(),tobj->getAngle(),tobj->getXSpeed(),tobj->getYSpeed(),tobj->getRotationSpeed(),tobj->getMotionAccel(),tobj->getRotationAccel());
        //                            unlockObjectList();
        //
        //                            for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
        //                                (*listener)->updateTuioObject(frameObject);
        //
        //                    }
        //                    delete tobj;
        //                }
        //
        //                for (std::list<TuioListener*>::iterator listener=listenerList.begin(); listener != listenerList.end(); listener++)
        //                    (*listener)->refresh(currentTime);
        //
        //            } else {
        //                for (std::list<TuioObject*>::iterator iter=frameObjects.begin(); iter != frameObjects.end(); iter++) {
        //                    TuioObject *tobj = (*iter);
        //                    delete tobj;
        //                }
        //            }
        //
        //            frameObjects.clear();
        //        }
    }
	
}
コード例 #19
0
ファイル: Scene2.cpp プロジェクト: miquelsoler/ConductrEnter
///--------------------------------------------------------------
void Scene2::handleDrag(InteractionSource interactionSource, int x, int y, int cursorId)
{
    if ((x < 0) || (x > ofGetWidth())) return;
    if ((y < 0) || (y > viewHeight)) return;

    int pressedObjectIndex;
    if (interactionSource == InteractionSourceMouse)
    {
        pressedObjectIndex = mouseObjectIndex;
    }
    else // Coming from TUIO
    {
        pressedObjectIndex = getObjectIndexWithCursor(cursorId);
        if (pressedObjectIndex == -1)
        {
            return;
        }
    }

    S2BaseObj *object = objects[pressedObjectIndex];

    if (!object->getIsPicked()) return;

    // Send message to Ableton

    int pressedClipIndex = getClipIndexAtY(y) + (artistIndex * artistOffset) + SettingsManager::getInstance().abletonFirstClipIndex;
    if (pressedClipIndex != currentClipIndex)
    {
        int track = pressedObjectIndex;

        AbletonManager::getInstance().stopClip(currentClipIndex, track);
        currentClipIndex = (unsigned int)pressedClipIndex;
        // Play Ableton clip
        AbletonManager::getInstance().playClip(currentClipIndex, track);
    }

    // Position object (only if mouse, or if TUIO and cursor is the first one -to avoid crazy repositioning-
    TuioCursor *firstCursor = object->getFirstCursor();

    bool mouseCondition = (interactionSource == InteractionSourceMouse);
    bool tuioCondition = (interactionSource == InteractionSourceTuio) && ((firstCursor == NULL) || (firstCursor->getCursorID() == cursorId));

    if (mouseCondition || tuioCondition)
    {
        object->setPositionFromScreenCoords(x, y);
    }

    // Update Ableton track

    int device = 0;
    int parameter = 1;
    int value = ofMap(object->getXOffset(), 0, object->getRadius(), 0, 127, true);
    AbletonManager::getInstance().setDeviceParameter(pressedObjectIndex, device, parameter, value);
}
コード例 #20
0
ファイル: VRTUIODevice.cpp プロジェクト: ivlab/MinVR
void VRTUIODevice::appendNewInputEventsSinceLastCall(VRDataQueue *inputEvents)
{

	// Send out events for TUIO "cursors" by polling the TuioClient for the current state
	std::list<TuioCursor*> cursorList = _tuioClient->getTuioCursors();
	_tuioClient->lockCursorList();

	// Send "button" up events for cursors that were down last frame, but are now up.
	std::vector<int> downLast;
	for (std::set<int>::iterator downLast_it = _cursorsDown.begin(); downLast_it!= _cursorsDown.end(); ++downLast_it ) {
		downLast.push_back(*downLast_it);
	}

	for (int i=0;i<downLast.size();i++) {
		bool stillDown = false;
		for (std::list<TuioCursor*>::iterator iter = cursorList.begin(); iter!=cursorList.end(); iter++) {
			TuioCursor *tcur = (*iter);
			if (tcur->getCursorID() == downLast[i]) {
				stillDown = true;
			}
		}
		if (!stillDown) {
			std::string event = "Touch_Cursor_Up";
			_dataIndex.addData(event + "/Id", downLast[i]);
			inputEvents->push(_dataIndex.serialize(event));
			_cursorsDown.erase(downLast[i]);
		}
	}

	// Send "button" down events for cursors that are new and updated positions for all cursors
	for (std::list<TuioCursor*>::iterator iter = cursorList.begin(); iter!=cursorList.end(); iter++) {
		TuioCursor *tcur = (*iter);

		if (_cursorsDown.find(tcur->getCursorID()) == _cursorsDown.end()) {
			std::string event = "Touch_Cursor_Down";
			_dataIndex.addData(event + "/Id", tcur->getCursorID());
			_dataIndex.addData(event + "/XPos", _xScale*tcur->getX());
			_dataIndex.addData(event + "/YPos", _yScale*tcur->getY());
			inputEvents->push(_dataIndex.serialize(event));
			_cursorsDown.insert(tcur->getCursorID());
		}

		if (tcur->getMotionSpeed() > 0.0) {
			std::string event = "Touch_Cursor_Move";
			_dataIndex.addData(event + "/Id", tcur->getCursorID());
			_dataIndex.addData(event + "/XPos", _xScale*tcur->getX());
			_dataIndex.addData(event + "/YPos", _yScale*tcur->getY());
			inputEvents->push(_dataIndex.serialize(event));
		}

		// Can also access several other properties of cursors (speed, acceleration, path followed, etc.)
		//std::cout << "cur " << tcur->getCursorID() << " (" <<  tcur->getSessionID() << ") " << tcur->getX() << " " << tcur->getY()
		// << " " << tcur->getMotionSpeed() << " " << tcur->getMotionAccel() << " " << std::endl;

		// This is how to access all the points in the path that a cursor follows:
		//std::list<TuioPoint> path = tuioCursor->getPath();
		//if (path.size() > 0) {
		//  TuioPoint last_point = path.front();
		//  for (std::list<TuioPoint>::iterator point = path.begin(); point!=path.end(); point++) {
		//    last_point.update(point->getX(),point->getY());
		//  }
		//}
	}

	_tuioClient->unlockCursorList();
}