//--------------------------------------------------------------
void testApp::setup() {
    
    Tweenzor::init( ) ; 
    ofSetLogLevel(OF_LOG_WARNING);

        bDrawOpenNI = false;
     
//#ifndef USE_ONI_MOVIE
    openNIDevice.setup();
    openNIDevice.addImageGenerator();
    openNIDevice.addDepthGenerator();
    openNIDevice.setRegister(true);
    openNIDevice.setMirror(false);
    openNIDevice.addUserGenerator();
    openNIDevice.setMaxNumUsers(4);
    openNIDevice.start();
    
    // set properties for all user masks and point clouds
    //openNIDevice.setUseMaskPixelsAllUsers(true); // if you just want pixels, use this set to true
    openNIDevice.setUseMaskTextureAllUsers(true); // this turns on mask pixels internally AND creates mask textures efficiently
    openNIDevice.setUsePointCloudsAllUsers(false);
   // openNIDevice.setPointCloudDrawSizeAllUsers(2); // size of each 'point' in the point cloud
   // openNIDevice.setPointCloudResolutionAllUsers(2); // resolution of the mesh created for the point cloud eg., this will use every second depth pixel
    
    // you can alternatively create a 'base' user class
//    ofxOpenNIUser user;
//    user.setUseMaskTexture(true);
//    user.setUsePointCloud(true);
//    user.setPointCloudDrawSize(2);
//    user.setPointCloudResolution(2);
//    openNIDevice.setBaseUserClass(user);
//#endif

    /*
    openNIPlayer.setup();
    openNIPlayer.addImageGenerator();
    openNIPlayer.addDepthGenerator();
    openNIPlayer.setRegister(true);
    openNIPlayer.setMirror(false);
    openNIPlayer.addUserGenerator();
    openNIPlayer.setMaxNumUsers(2);
	openNIPlayer.start();
    
    openNIPlayer.setUseMaskTextureAllUsers(true); // this turns on mask pixels internally AND creates mask textures efficiently
    openNIPlayer.setUsePointCloudsAllUsers(false);*/
   // openNIPlayer.setPointCloudDrawSizeAllUsers(2); // size of each 'point' in the point cloud
   // openNIPlayer.setPointCloudResolutionAllUsers(2); // resolution of the mesh created for the point cloud eg., this will use every second depth pixel
    
    colorPool.push_back( ofColor( 242, 56 , 90 ) ) ;
    colorPool.push_back( ofColor( 245, 165 , 3 ) ) ;
    colorPool.push_back( ofColor( 233, 241 , 223 ) ) ;
    colorPool.push_back( ofColor( 74, 217 , 217 ) ) ;
    colorPool.push_back( ofColor( 54, 177 , 191 ) ) ;
    verdana.loadFont(ofToDataPath("verdana.ttf"), 24);
    
    roiArea = ofRectangle( ofRandomWidth() , ofRandomHeight() , ofRandomWidth() , ofRandomHeight() ) ;
    bUseRoi = false ;
    bFullscreen = false ;
    
    bCalibrateSpace = true ;
       
    loadRoiCalibration() ;
    
    init_ofxUI ( ) ;
    
    for ( int i = 0 ; i < 15 ; i++ )
    {
        JointRoute jr ;
        jointRoutes.push_back( jr ) ;
        skeleton.push_back ( ofPoint() ) ; 
    }
    
    jointRoutes[0].addIndex(1) ;
    jointRoutes[0].addIndex(9) ;
    jointRoutes[0].addIndex(12) ;
    
    jointRoutes[1].addIndex(3) ;
    jointRoutes[1].addIndex(6) ;
    jointRoutes[1].addIndex(2) ;
    jointRoutes[2].addIndex(-1) ;
    
    jointRoutes[3].addIndex(4) ;
    jointRoutes[3].addIndex(4) ;
    jointRoutes[4].addIndex(5) ;
    jointRoutes[4].addIndex(5) ;
    jointRoutes[5].addIndex(-1) ;
    
    jointRoutes[6].addIndex(7) ;
    jointRoutes[6].addIndex(7) ;
    jointRoutes[7].addIndex(8) ;
    jointRoutes[7].addIndex(8) ;
    jointRoutes[8].addIndex(-1) ;
    jointRoutes[9].addIndex(10) ;
    jointRoutes[10].addIndex(11) ;
    jointRoutes[11].addIndex(-1) ;
    
    jointRoutes[12].addIndex(13) ;
    jointRoutes[13].addIndex(14) ;
    jointRoutes[14].addIndex(-1) ;

    
    lastSpawn = 0 ;
    spawnDelay = 1.5f ;
    bDepthRegistration = false ;
      
    fbo.allocate( ofGetWidth() , ofGetHeight() , GL_RGBA ) ;
    fbo.begin() ;
        ofClear( 1 , 1 , 1, 0 ) ; 
    fbo.end() ;

    bSkeletonActive = false ;

}
Example #2
0
//--------------------------------------------------------------
ofMesh pen::extrudeMesh(ofMesh mesh, ofColor color){ 
    
    ofMesh side; 
    float depth = 50; 
    color.setBrightness(250);
    
    vector<ofPoint> points = mesh.getVertices();
    int k;
    
    if (points.size() > 4){
        ofPoint p1 = points[0];
        ofPoint p2 = points[1];
        
        side.addVertex(p1);
        side.addColor(color);
        side.addVertex(p2);
        side.addColor(color);
        side.addVertex(ofPoint(p1.x, p1.y, p1.z-depth));
        side.addColor(color);
        side.addVertex(ofPoint(p1.x, p1.y, p1.z-depth));
        side.addColor(color);
        side.addVertex(ofPoint(p2.x, p2.y, p2.z-depth));
        side.addColor(color);
        side.addVertex(p2);
        side.addColor(color);
        
        for(k=0; k<points.size()-2; k++)
        {
            
            ofPoint p1 = points[k+0];
            ofPoint p2 = points[k+2];
            
            side.addVertex(p1);
            side.addColor(color);
            side.addVertex(p2);
            side.addColor(color);
            side.addVertex(ofPoint(p1.x+5, p1.y, p1.z-depth));
            side.addColor(color);
            if (ofRandom(0,25) < 1)
                color.setBrightness(ofMap(k, 0, points.size(), 100, 50));
            else 
                color.setBrightness(ofMap(k, 0, points.size(), 150, 100));
            side.addVertex(ofPoint(p1.x+5, p1.y, p1.z-depth));
            side.addColor(color);
            side.addVertex(ofPoint(p2.x+5, p2.y, p2.z-depth));
            side.addColor(color);
            side.addVertex(p2);
            side.addColor(color);
        }
        
        p1 = points[points.size()-2];
        p2 = points[points.size()-1];
        side.addVertex(p1);
        side.addColor(color);
        side.addVertex(p2);
        side.addColor(color);
        side.addVertex(ofPoint(p1.x, p1.y, p1.z-depth));
        side.addColor(color);
        side.addVertex(ofPoint(p1.x, p1.y, p1.z-depth));
        side.addColor(color);
        side.addVertex(ofPoint(p2.x, p2.y, p2.z-depth));
        side.addColor(color);
        side.addVertex(p2);
        side.addColor(color);
    }
    return side;
    
}
void ofxTLAudioTrack::recomputePreview(){
	
	previews.clear();
	
//	cout << "recomputing view with zoom bounds of " << zoomBounds << endl;
	
	float normalizationRatio = timeline->getDurationInSeconds() / player.getDuration(); //need to figure this out for framebased...but for now we are doing time based
	float trackHeight = bounds.height/(1+player.getNumChannels());
	int numSamples = player.getBuffer().size() / player.getNumChannels();
	int pixelsPerSample = numSamples / bounds.width;
	int numChannels = player.getNumChannels();
	vector<short> & buffer  = player.getBuffer();

	for(int c = 0; c < numChannels; c++){
		ofPolyline preview;
		int lastFrameIndex = 0;
		preview.resize(bounds.width*2);  //Why * 2? Because there are two points per pixel, center and outside. 
		for(float i = bounds.x; i < bounds.x+bounds.width; i++){
			float pointInTrack = screenXtoNormalizedX( i ) * normalizationRatio; //will scale the screenX into wave's 0-1.0
			float trackCenter = bounds.y + trackHeight * (c+1);
			
			ofPoint * vertex = & preview.getVertices()[ (i - bounds.x) * 2];
			
			if(pointInTrack >= 0 && pointInTrack <= 1.0){
				//draw sample at pointInTrack * waveDuration;
				int frameIndex = pointInTrack * numSamples;					
				float losample = 0;
				float hisample = 0;
				for(int f = lastFrameIndex; f < frameIndex; f++){
					int sampleIndex = f * numChannels + c;
					float subpixelSample = buffer[sampleIndex]/32565.0;
					if(subpixelSample < losample) {
						losample = subpixelSample;
					}
					if(subpixelSample > hisample) {
						hisample = subpixelSample;
					}
				}
				
				if(losample == 0 && hisample == 0){
					//preview.addVertex(i, trackCenter);
					vertex->x = i;
					vertex->y = trackCenter;
					vertex++;
				}
				else {
					if(losample != 0){
//						preview.addVertex(i, trackCenter - losample * trackHeight);
						vertex->x = i;
						vertex->y = trackCenter - losample * trackHeight*.5;
						vertex++;
					}
					if(hisample != 0){
						//ofVertex(i, trackCenter - hisample * trackHeight);
//						preview.addVertex(i, trackCenter - hisample * trackHeight);
						vertex->x = i;
						vertex->y = trackCenter - hisample * trackHeight*.5;
						vertex++;
					}
				}
				
				while (vertex < & preview.getVertices()[ (i - bounds.x) * 2] + 2) {
					*vertex = *(vertex-1);
					vertex++;
				}

				lastFrameIndex = frameIndex;
			}
			else{
				*vertex++ = ofPoint(i,trackCenter);
				*vertex++ = ofPoint(i,trackCenter);
			}
		}
		preview.simplify();
		previews.push_back(preview);
	}
	computedZoomBounds = zoomBounds;
	shouldRecomputePreview = false;
}
Example #4
0
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){

    if (mode == MODE_NORMAL){


        // check the mouse for press

        for (int i = 0; i < buttons.size(); i++){
            buttons[i].checkMousePressed(ofPoint(x, y));
        }
        

        //-------------------------------------
        // 4 = genearate
        //-------------------------------------

        
        if (generateButton.bMouseOver == true){
            generateProject();
        }

        //-------------------------------------
        // 0 = sketch name
        //-------------------------------------

        if (buttons[0].bMouseOver == true){
            string text = ofSystemTextBoxDialog("choose sketch name", buttons[0].myText);
            fixStringCharacters(text);
            setStatus("sketch name set to: " + text);
            buttons[0].setText(text);
        }

        //-------------------------------------
        // 1 = sketch path
        //-------------------------------------

        if (buttons[1].bMouseOver == true){

            string command = "";

            ofDirectory dir(ofFilePath::join(getOFRoot(),defaultLoc));

            if (!dir.exists()){
                dir.create();
            }

          	
        #ifdef TARGET_WIN32
                    ofFileDialogResult res = ofSystemLoadDialog("please select sketch folder", true, windowsFromUnixPath(dir.path()));
        #else 
                    ofFileDialogResult res = ofSystemLoadDialog("please select sketch folder", true, dir.path());
        #endif
            

            if (res.bSuccess){
                string result = res.filePath;
                convertWindowsToUnixPath(result);
                buttons[1].setText( result );
                
                setStatus("path set to: " + result);
            }


        }


        //-------------------------------------
        // 2 = platform  (disabled)
        //-------------------------------------


        if (buttons[2].bMouseOver == true){
            // platform is diabled for now
             mode = 2;
        }

        //-------------------------------------
        // 3 = addon
        //-------------------------------------

        if (buttons[3].bMouseOver == true){
            mode = MODE_ADDON;

        }
    }

    //-------------------------------------
    // handle addon mode
    //-------------------------------------

    if (mode == MODE_ADDON ){

        //-------------------------------------
        // if we hit he back button, collect the addons for display
        //-------------------------------------

        if (addonButton.bMouseOver){

            string addons = "";

            for (int i = 0; i < panelCoreAddons.getNumControls(); i++){
                if (*((ofxToggle *)panelCoreAddons.getControl(i))){
                   if (addons.length() > 0) addons+=", ";
                    addons += ((ofxToggle *)panelCoreAddons.getControl(i))->getName();

                }

            }
            for (int i = 0; i < panelOtherAddons.getNumControls(); i++){
                if (*((ofxToggle *)panelOtherAddons.getControl(i))){
                    if (addons.length() > 0) addons+=", ";
                    addons += ((ofxToggle *)panelOtherAddons.getControl(i))->getName();

                }

            }
            buttons[3].setText(addons);

            setStatus("addons set to: " + addons);

            addonButton.bMouseOver = false;
            mode = MODE_NORMAL;
        }
    }

    if (mode == MODE_PLATFORM){

    }
}
Example #5
0
//------------------------------------------------
Ragdoll::Ragdoll(ofxMtlBox2dWorld *world, int x, int y)
{
    // build the head
    ofxMtlBox2dCircle *head = new ofxMtlBox2dCircle();
    head->setPhysics(1.0f, 0.4f, 0.3f);
    head->setup(world, x, y, 25.0f);
    parts.push_back(head);

    // build the torso in 3 parts
    ofxMtlBox2dBox *shoulders = new ofxMtlBox2dBox();
    shoulders->setPhysics(1.0f, 0.4f, 0.1f);
    shoulders->setup(world, x, y + 50.0f, 30.0f, 20.0f);
    parts.push_back(shoulders);

    ofxMtlBox2dBox *stomach = new ofxMtlBox2dBox();
    stomach->setPhysics(1.0f, 0.4f, 0.1f);
    stomach->setup(world, x, y + 86.0f, 30.0f, 20.0f);
    parts.push_back(stomach);

    ofxMtlBox2dBox *hips = new ofxMtlBox2dBox();
    hips->setPhysics(1.0f, 0.4f, 0.1f);
    hips->setup(world, x, y + 116.0f, 30.0f, 20.0f);
    parts.push_back(hips);

    // build the arms
    ofxMtlBox2dBox *upperArmLeft = new ofxMtlBox2dBox();
    upperArmLeft->setPhysics(1.0f, 0.4f, 0.1f);
    upperArmLeft->setup(world, x - 60.0f, y + 40.0f, 36.0f, 13.0f);
    parts.push_back(upperArmLeft);

    ofxMtlBox2dBox *upperArmRight = new ofxMtlBox2dBox();
    upperArmRight->setPhysics(1.0f, 0.4f, 0.1f);
    upperArmRight->setup(world, x + 60.0f, y + 40.0f, 36.0f, 13.0f);
    parts.push_back(upperArmRight);

    ofxMtlBox2dBox *lowerArmLeft = new ofxMtlBox2dBox();
    lowerArmLeft->setPhysics(1.0f, 0.4f, 0.1f);
    lowerArmLeft->setup(world, x - 114.0f, y + 40.0f, 34.0f, 12.0f);
    parts.push_back(lowerArmLeft);

    ofxMtlBox2dBox *lowerArmRight = new ofxMtlBox2dBox();
    lowerArmRight->setPhysics(1.0f, 0.4f, 0.1f);
    lowerArmRight->setup(world, x + 114.0f, y + 40.0f, 34.0f, 12.0f);
    parts.push_back(lowerArmRight);

    // build the legs
    ofxMtlBox2dBox *upperLegLeft = new ofxMtlBox2dBox();
    upperLegLeft->setPhysics(1.0f, 0.4f, 0.1f);
    upperLegLeft->setup(world, x - 16.0f, y + 170.0f, 15.0f, 44.0f);
    parts.push_back(upperLegLeft);

    ofxMtlBox2dBox *upperLegRight = new ofxMtlBox2dBox();
    upperLegRight->setPhysics(1.0f, 0.4f, 0.1f);
    upperLegRight->setup(world, x + 16.0f, y + 170.0f, 15.0f, 44.0f);
    parts.push_back(upperLegRight);

    ofxMtlBox2dBox *lowerLegLeft = new ofxMtlBox2dBox();
    lowerLegLeft->setPhysics(1.0f, 0.4f, 0.1f);
    lowerLegLeft->setup(world, x - 16.0f, y + 240.0f, 12.0f, 40.0f);
    parts.push_back(lowerLegLeft);

    ofxMtlBox2dBox *lowerLegRight = new ofxMtlBox2dBox();
    lowerLegRight->setPhysics(1.0f, 0.4f, 0.1f);
    lowerLegRight->setup(world, x + 16.0f, y + 240.0f, 12.0f, 40.0f);
    parts.push_back(lowerLegRight);

    // build the joints
    ofxMtlBox2dRevoluteJoint *head2Shoulders = new ofxMtlBox2dRevoluteJoint();
    head2Shoulders->setLimitEnabled(true);
    head2Shoulders->setLimits(-40.0, 40.0);
    head2Shoulders->setup(world, shoulders, head, ofPoint(x, y + 30.0f));
    joints.push_back(head2Shoulders);

    ofxMtlBox2dRevoluteJoint *upperArm2ShouldersLeft = new ofxMtlBox2dRevoluteJoint();
    upperArm2ShouldersLeft->setLimitEnabled(true);
    upperArm2ShouldersLeft->setLimits(-85.0, 130.0);
    upperArm2ShouldersLeft->setup(world, shoulders, upperArmLeft, ofPoint(x - 36.0f, y + 40.0f));
    joints.push_back(upperArm2ShouldersLeft);

    ofxMtlBox2dRevoluteJoint *upperArm2ShouldersRight = new ofxMtlBox2dRevoluteJoint();
    upperArm2ShouldersRight->setLimitEnabled(true);
    upperArm2ShouldersRight->setLimits(-130.0, 85.0);
    upperArm2ShouldersRight->setup(world, shoulders, upperArmRight, ofPoint(x + 36.0f, y + 40.0f));
    joints.push_back(upperArm2ShouldersRight);

    ofxMtlBox2dRevoluteJoint *upper2LowerArmLeft = new ofxMtlBox2dRevoluteJoint();
    upper2LowerArmLeft->setLimitEnabled(true);
    upper2LowerArmLeft->setLimits(-130.0, 10.0);
    upper2LowerArmLeft->setup(world, upperArmLeft, lowerArmLeft, ofPoint(x - 90.0f, y + 40.0f));
    joints.push_back(upper2LowerArmLeft);

    ofxMtlBox2dRevoluteJoint *upper2LowerArmRight = new ofxMtlBox2dRevoluteJoint();
    upper2LowerArmRight->setLimitEnabled(true);
    upper2LowerArmRight->setLimits(-10.0, 130.0);
    upper2LowerArmRight->setup(world, upperArmRight, lowerArmRight, ofPoint(x + 90.0f, y + 40.0f));
    joints.push_back(upper2LowerArmRight);

    ofxMtlBox2dRevoluteJoint *shoulders2Stomach = new ofxMtlBox2dRevoluteJoint();
    shoulders2Stomach->setLimitEnabled(true);
    shoulders2Stomach->setLimits(-15.0, 15.0);
    shoulders2Stomach->setup(world, shoulders, stomach, ofPoint(x, y + 70.0f));
    joints.push_back(shoulders2Stomach);

    ofxMtlBox2dRevoluteJoint *stomach2Hips = new ofxMtlBox2dRevoluteJoint();
    stomach2Hips->setLimitEnabled(true);
    stomach2Hips->setLimits(-15.0, 15.0);
    stomach2Hips->setup(world, stomach, hips, ofPoint(x, y + 100.0f));
    joints.push_back(stomach2Hips);

    ofxMtlBox2dRevoluteJoint *hips2upperLegLeft = new ofxMtlBox2dRevoluteJoint();
    hips2upperLegLeft->setLimitEnabled(true);
    hips2upperLegLeft->setLimits(-25.0, 45.0);
    hips2upperLegLeft->setup(world, hips, upperLegLeft, ofPoint(x - 16.0f, y + 144.0f));
    joints.push_back(hips2upperLegLeft);

    ofxMtlBox2dRevoluteJoint *hips2upperLegRight = new ofxMtlBox2dRevoluteJoint();
    hips2upperLegRight->setLimitEnabled(true);
    hips2upperLegRight->setLimits(-45.0, 25.0);
    hips2upperLegRight->setup(world, hips, upperLegRight, ofPoint(x + 16.0f, y + 144.0f));
    joints.push_back(hips2upperLegRight);

    ofxMtlBox2dRevoluteJoint *upper2LowerLegLeft = new ofxMtlBox2dRevoluteJoint();
    upper2LowerLegLeft->setLimitEnabled(true);
    upper2LowerLegLeft->setLimits(-25.0, 115.0);
    upper2LowerLegLeft->setup(world, upperLegLeft, lowerLegLeft, ofPoint(x - 16.0f, y + 210.0f));
    joints.push_back(upper2LowerLegLeft);

    ofxMtlBox2dRevoluteJoint *upper2LowerLegRight = new ofxMtlBox2dRevoluteJoint();
    upper2LowerLegRight->setLimitEnabled(true);
    upper2LowerLegRight->setLimits(-115.0, 25.0);
    upper2LowerLegRight->setup(world, upperLegRight, lowerLegRight, ofPoint(x + 16.0f, y + 210.0f));
    joints.push_back(upper2LowerLegRight);

    // build the controls
    leftArmControl = new Control(world, lowerArmLeft, ofPoint(-114.0f, -280.0f), lowerArmLeft->getPosition() - ofPoint(lowerArmLeft->getWidth() / 2, 0));
    rightArmControl = new Control(world, lowerArmRight, ofPoint(114.0f, -280.0f), lowerArmRight->getPosition() + ofPoint(lowerArmRight->getWidth() / 2, 0));
    leftLegControl = new Control(world, lowerLegLeft, ofPoint(-100.0f, -420.0f), lowerLegLeft->getPosition() + ofPoint(0, lowerLegLeft->getHeight() / 2));
    rightLegControl = new Control(world, lowerLegRight, ofPoint(100.0f, -420.0f), lowerLegRight->getPosition() + ofPoint(0, lowerLegRight->getHeight() / 2));
    headControl = new Control(world, head, ofPoint(0, -200.0f), head->getPosition());
}
Example #6
0
 //--------------------------------------------------------------
 ofPoint Person::getHaarCentroidNormalized(float videoWidth, float videoHeight){
     ofRectangle haarRect = getHaarRect();
     return ofPoint( (haarRect.x + haarRect.width/2) / videoWidth, (haarRect.y + haarRect.height/2) / videoHeight );
 }
//--------------------------------------------------------------------------------
int ContourFinder::findContours(	ofxCvGrayscaleImage&  input,
									int minArea,
									int maxArea,
									int nConsidered,
									double hullPress,	
									bool bFindHoles,
									bool bUseApproximation  ) {
	reset();

	// opencv will clober the image it detects contours on, so we want to
    // copy it into a copy before we detect contours.  That copy is allocated
    // if necessary (necessary = (a) not allocated or (b) wrong size)
	// so be careful if you pass in different sized images to "findContours"
	// there is a performance penalty, but we think there is not a memory leak
    // to worry about better to create mutiple contour finders for different
    // sizes, ie, if you are finding contours in a 640x480 image but also a
    // 320x240 image better to make two ContourFinder objects then to use
    // one, because you will get penalized less.

	if( inputCopy.width == 0 ) {
		inputCopy.allocate( input.width, input.height );
		inputCopy = input;
	} else {
		if( inputCopy.width == input.width && inputCopy.height == input.height ) 
			inputCopy = input;
		else {
			// we are allocated, but to the wrong size --
			// been checked for memory leaks, but a warning:
			// be careful if you call this function with alot of different
			// sized "input" images!, it does allocation every time
			// a new size is passed in....
			//inputCopy.clear();
			inputCopy.allocate( input.width, input.height );
			inputCopy = input;
		}
	}

	CvSeq* contour_list = NULL;
	contour_storage = cvCreateMemStorage( 1000 );
	storage	= cvCreateMemStorage( 1000 );

	CvContourRetrievalMode  retrieve_mode
        = (bFindHoles) ? CV_RETR_LIST : CV_RETR_EXTERNAL;
	cvFindContours( inputCopy.getCvImage(), contour_storage, &contour_list,
                    sizeof(CvContour), retrieve_mode, bUseApproximation ? CV_CHAIN_APPROX_SIMPLE : CV_CHAIN_APPROX_NONE );
	
	CvSeq* contour_ptr = contour_list;

	nCvSeqsFound = 0;

	// put the contours from the linked list, into an array for sorting
	while( (contour_ptr != NULL) )  {
		CvBox2D box = cvMinAreaRect2(contour_ptr);
		int objectId; // If the contour is an object, then objectId is its ID
		objectId = (bTrackObjects)? templates->getTemplateId(box.size.width,box.size.height): -1;
		
		if(objectId != -1 ) { //If the blob is a object
			Blob blob		= Blob();
			blob.id			= objectId;
			blob.isObject	= true;
			float area = cvContourArea( contour_ptr, CV_WHOLE_SEQ );

			cvMoments( contour_ptr, myMoments );
		
			// this is if using non-angle bounding box
			CvRect rect	= cvBoundingRect( contour_ptr, 0 );
			blob.boundingRect.x      = rect.x;
			blob.boundingRect.y      = rect.y;
			blob.boundingRect.width  = rect.width;
			blob.boundingRect.height = rect.height;

			//For anglebounding rectangle
			blob.angleBoundingBox=box;
			blob.angleBoundingRect.x	  = box.center.x;
			blob.angleBoundingRect.y	  = box.center.y;
			blob.angleBoundingRect.width  = box.size.height;
			blob.angleBoundingRect.height = box.size.width;
			blob.angle = box.angle;

			//TEMPORARY INITIALIZATION TO 0, Will be calculating afterwards.This is to prevent sending wrong data
			blob.D.x = 0;
			blob.D.y = 0;
			blob.maccel = 0;

			// assign other parameters
			blob.area                = fabs(area);
			blob.hole                = area < 0 ? true : false;
			blob.length 			 = cvArcLength(contour_ptr);
		
			blob.centroid.x			 = (myMoments->m10 / myMoments->m00);
			blob.centroid.y 		 = (myMoments->m01 / myMoments->m00);
			blob.lastCentroid.x 	 = 0;
			blob.lastCentroid.y 	 = 0;

			// get the points for the blob:
			CvPoint           pt;
			CvSeqReader       reader;
			cvStartReadSeq( contour_ptr, &reader, 0 );
	
    		for( int j=0; j < contour_ptr->total; j++ ) {
				CV_READ_SEQ_ELEM( pt, reader );
				blob.pts.push_back( ofPoint((float)pt.x, (float)pt.y) );
			}
			blob.nPts = blob.pts.size();

			objects.push_back(blob);
			
		} else if ( bTrackBlobs ) { // SEARCH FOR BLOBS
			float area = fabs( cvContourArea(contour_ptr, CV_WHOLE_SEQ) );
			if( (area > minArea) && (area < maxArea) ) {
				Blob blob=Blob();
				float area = cvContourArea( contour_ptr, CV_WHOLE_SEQ );
				cvMoments( contour_ptr, myMoments );
				
				// this is if using non-angle bounding box
				CvRect rect	= cvBoundingRect( contour_ptr, 0 );
				blob.boundingRect.x      = rect.x;
				blob.boundingRect.y      = rect.y;
				blob.boundingRect.width  = rect.width;
				blob.boundingRect.height = rect.height;
				
				//Angle Bounding rectangle
				blob.angleBoundingRect.x	  = box.center.x;
				blob.angleBoundingRect.y	  = box.center.y;
				blob.angleBoundingRect.width  = box.size.height;
				blob.angleBoundingRect.height = box.size.width;
				blob.angle = box.angle;
				
				// assign other parameters
				blob.area                = fabs(area);
				blob.hole                = area < 0 ? true : false;
				blob.length 			 = cvArcLength(contour_ptr);
				// AlexP
				// The cast to int causes errors in tracking since centroids are calculated in
				// floats and they migh land between integer pixel values (which is what we really want)
				// This not only makes tracking more accurate but also more fluid
				blob.centroid.x			 = (myMoments->m10 / myMoments->m00);
				blob.centroid.y 		 = (myMoments->m01 / myMoments->m00);
				blob.lastCentroid.x 	 = 0;
				blob.lastCentroid.y 	 = 0;
				
				// get the points for the blob:
				CvPoint           pt;
				CvSeqReader       reader;
				cvStartReadSeq( contour_ptr, &reader, 0 );
				
    			for( int j=0; j < min(TOUCH_MAX_CONTOUR_LENGTH, contour_ptr->total); j++ ) {
					CV_READ_SEQ_ELEM( pt, reader );
					blob.pts.push_back( ofPoint((float)pt.x, (float)pt.y) );
				}
				blob.nPts = blob.pts.size();
				
				blobs.push_back(blob);
			}
		} 
		contour_ptr = contour_ptr->h_next;
	}
		
	if ( bTrackFingers ) {  // SEARCH FOR FINGERS
		CvPoint*		PointArray;
		int*			hull;
		int				hullsize;
		
		if (contour_list)
			contour_list = cvApproxPoly(contour_list, sizeof(CvContour), storage, CV_POLY_APPROX_DP, hullPress, 1 );
			
		for( ; contour_list != 0; contour_list = contour_list->h_next ){
			int count = contour_list->total; // This is number point in contour
				
			CvRect rect = cvContourBoundingRect(contour_list, 1);
			
			if ( (rect.width*rect.height) > 300 ){		// Analize the bigger contour
				CvPoint center;
				center.x = rect.x+rect.width/2;
				center.y = rect.y+rect.height/2;
				
				PointArray = (CvPoint*)malloc( count*sizeof(CvPoint) ); // Alloc memory for contour point set.
				hull = (int*)malloc(sizeof(int)*count);	// Alloc memory for indices of convex hull vertices.
					
				cvCvtSeqToArray(contour_list, PointArray, CV_WHOLE_SEQ); // Get contour point set.
					
				// Find convex hull for curent contour.
				cvConvexHull(	PointArray,
								count,
								NULL,
								CV_COUNTER_CLOCKWISE,
								hull,
								&hullsize);
					
				int upper = 640, lower = 0;
				for	(int j=0; j<hullsize; j++) {
					int idx = hull[j]; // corner index
					if (PointArray[idx].y < upper) 
						upper = PointArray[idx].y;
					if (PointArray[idx].y > lower) 
						lower = PointArray[idx].y;
				}
				
				float cutoff = lower - (lower - upper) * 0.1f;
				// find interior angles of hull corners
				for (int j=0; j<hullsize; j++) {
					int idx = hull[j]; // corner index
					int pdx = idx == 0 ? count - 1 : idx - 1; //  predecessor of idx
					int sdx = idx == count - 1 ? 0 : idx + 1; // successor of idx
						
					cv::Point v1 = cv::Point(PointArray[sdx].x - PointArray[idx].x, PointArray[sdx].y - PointArray[idx].y);
					cv::Point v2 = cv::Point(PointArray[pdx].x - PointArray[idx].x, PointArray[pdx].y - PointArray[idx].y);
						
					float angle = acos( (v1.x*v2.x + v1.y*v2.y) / (norm(v1) * norm(v2)) );
						
					// low interior angle + within upper 90% of region -> we got a finger
					if (angle < 1 ){ //&& PointArray[idx].y < cutoff) {
						Blob blob = Blob();
						
						//float area = cvContourArea( contour_ptr, CV_WHOLE_SEQ );
						//cvMoments( contour_ptr, myMoments );
						
						// this is if using non-angle bounding box
						//CvRect rect	= cvBoundingRect( contour_ptr, 0 );
						blob.boundingRect.x      = PointArray[idx].x-5;
						blob.boundingRect.y      = PointArray[idx].y-5;
						blob.boundingRect.width  = 10;
						blob.boundingRect.height = 10;
						
						//Angle Bounding rectangle
						blob.angleBoundingRect.x	  = PointArray[idx].x-5;
						blob.angleBoundingRect.y	  = PointArray[idx].y-5;
						blob.angleBoundingRect.width  = 10;
						blob.angleBoundingRect.height = 10;
						blob.angle = atan2(PointArray[idx].x - center.x , PointArray[idx].y - center.y);
						
						// assign other parameters
						//blob.area                = fabs(area);
						//blob.hole                = area < 0 ? true : false;
						//blob.length 			 = cvArcLength(contour_ptr);
						// AlexP
						// The cast to int causes errors in tracking since centroids are calculated in
						// floats and they migh land between integer pixel values (which is what we really want)
						// This not only makes tracking more accurate but also more fluid
						blob.centroid.x			 = PointArray[idx].x;//(myMoments->m10 / myMoments->m00);
						blob.centroid.y 		 = PointArray[idx].y;//(myMoments->m01 / myMoments->m00);
						blob.lastCentroid.x 	 = 0;
						blob.lastCentroid.y 	 = 0;
						
						fingers.push_back(blob);
					}
				}
				// Free memory.
				free(PointArray);
				free(hull);
			}
		}
	}
	
	nBlobs = blobs.size();
	nFingers = fingers.size();
	nObjects = objects.size();
	
	// Free the storage memory.
	// Warning: do this inside this function otherwise a strange memory leak
	if( contour_storage != NULL )
		cvReleaseMemStorage(&contour_storage);
	
	if( storage != NULL )
		cvReleaseMemStorage(&storage);

	return (bTrackFingers)? nFingers:nBlobs;
}
Example #8
0
//--------------------------------------------------------------
void ofApp::setup(){
    
    camWidth = 1024;
    camHeight = 768;
    projWidth = 1024;
    projHeight = 768;
    canvasHeight = ofGetHeight() / 3 - 10;
    canvasWidth = canvasHeight * 4 / 3;
    outputHeight = ofGetHeight() * 2 / 3 - 10;
    outputWidth = outputHeight * 4 / 3;
    guiPos = ofPoint(10,10);
    canvas1Pos = ofPoint(ofGetWidth()/3 + 5, 5);
    canvas2Pos = ofPoint(ofGetWidth()*2/3 + 5, 5);
    outputPos = ofPoint(ofGetWidth()/3 + 5, ofGetHeight()/3+5);
    
    ofSetWindowTitle("FaceMapper - OTU CINEMA SL");
    
    CGDisplayCount displayCount;
    CGDirectDisplayID displays[32];
    
    // grab the active displays
    CGGetActiveDisplayList(32, displays, &displayCount);
    
    cout<<"displayCount "<<displayCount<<endl;
    
	vidGrabber.setVerbose(true);
	vidGrabber.initGrabber(camWidth, camHeight);
	colorImg.allocate(camWidth, camHeight);
	grayImage.allocate(canvasWidth, canvasHeight);
    warpedImg.allocate(canvasWidth, canvasHeight);
    
    if (displayCount == 1) {
        
        whichDisplay = 0;
        mainDisplayWidth = CGDisplayPixelsWide ( displays[whichDisplay] );
        mainDisplayWidth = CGDisplayPixelsHigh ( displays[whichDisplay] );
        
    }
    
    else {
        
        whichDisplay = 1;
        mainDisplayWidth = CGDisplayPixelsWide ( displays[0] );
        mainDisplayHeight = CGDisplayPixelsHigh ( displays[0] );
        secondDisplayWidth = CGDisplayPixelsWide ( displays[whichDisplay] );
        secondDisplayHeight = CGDisplayPixelsHigh ( displays[whichDisplay] );
        
    }
    
    
    // the arguments for the second window are its initial x and y position,
    // and its width and height. the last argument is whether the window
    // should be undecorated, i.e. title bar is visible. setting it to
    // true removes the title bar.
    
    
    if (displayCount == 1) secondWindow.setup("Output", 0, 0, 640, 480, false);
    else secondWindow.setup("Output", mainDisplayWidth, 0, secondDisplayWidth, secondDisplayHeight, true);
    
    
	threshold = 80;
	bLearnBakground = true;
	backgroundSubOn = false;
	
	//detect finger is off by default
	fidfinder.detectFinger		= false;
	//fidfinder.maxFingerSize		= 25;
	//fidfinder.minFingerSize		= 5;
	//fidfinder.fingerSensitivity	= 0.05f; //from 0 to 2.0f
        
    gui.setup("Control Panel"); // most of the time you don't need a name
    gui.add(selection.setup("Image Selection", false));
    gui.add(warping.setup("Warping Mode", false));
    gui.add(threshold.setup("Threshold", 160, 0, 255));
    gui.add(tableWidth.setup("Largo Mesa (cm)", 200, 10, 500));
    gui.add(tableHeight.setup("Ancho Mesa (cm)", 100, 10, 500));
    
    // Definimos los puntos de recorte de ROI (warping inverso de imagen de entrada)
    roiCorners[0] = ofPoint(10,10);
    roiCorners[1] = ofPoint(canvasWidth-10, 10);
    roiCorners[2] = ofPoint(canvasWidth - 10, canvasHeight - 10);
    roiCorners[3] = ofPoint(10,canvasHeight - 10);
    destCorners[0] = ofPoint(0,0);
    destCorners[1] = ofPoint(canvasWidth, 0);
    destCorners[2] = ofPoint(canvasWidth, canvasHeight);
    destCorners[3] = ofPoint(0,canvasHeight);
    
    for (int i = 0; i < 4; i++) {
        
        activeCorners[i] = false;
        
    }
    
    // Inicializamos los canvas
    
    canvas1.allocate(canvasWidth, canvasHeight, GL_RGB);
    canvas2.allocate(canvasWidth, canvasHeight, GL_RGB);
    canvasWarp.allocate(canvasWidth, canvasHeight, GL_RGB);
    output.allocate(outputWidth, outputHeight, GL_RGB);
    warpedOutput.allocate(outputWidth, outputHeight, GL_RGB);
    
    
    pixels.allocate(canvasWidth, canvasHeight, GL_RGB);

    // Inicializamos el quad
    quadRoi.setMode(OF_PRIMITIVE_LINE_LOOP);
    
    for(int i = 0; i < 4; i++) {
        
        quadRoi.addVertex(roiCorners[i]);

    }
    
    // Inicializamos el warper
    
    
    warperGui.setup(outputPos.x, outputPos.y, outputWidth, outputHeight);
    warperGui.activate();
    
    warperOutput.setup(mainDisplayWidth, 0, secondDisplayWidth, secondDisplayHeight);; //initializates ofxGLWarper
    
    // Inicializamos el objeto "Bola"
    //lets setup some stupid particles
    for(int i = 0; i < 10; i++){
        
        cards[i].setup(i);

    }
}
//--------------------------------------------------------------
void ofApp::update(){
//ofSeedRandom();
    // apply steering force

    float area = 50;

    for (int i=0; i<cars.size(); i++){
        cars[i].seek(destinations[i], 1.5, 0.2);

        for (int j=0; j<cars.size(); j++){
            if (i != j) {
                if (cars[i].getPosition().distance(cars[j].getPosition()) < area) {
                    cars[i].color = ofColor(255,0,0);
                    cars[j].color = ofColor(255,0,0);
                    cars[i].addRepulsionForce( cars[j].getPosition(), area,  0.1 );
                    cars[j].addRepulsionForce( cars[i].getPosition(), area,  0.1 );
                    //ofSeedRandom();
                    destinations[i] += ofPoint(ofRandomf(),ofRandomf());
                    //float lerpX = destinations[i].x;
                    //float lerpY = destinations[i].y;
                    //destinations[i].x = ofLerp(lerpX,cars[i].getPosition().distance(destinations[i]).x*-1, 0.1);
                    //destinations[i].y = ofLerp(lerpY,ofGetHeight(), 0.1);
                } else {
                    cars[i].color = colors[i];
                    cars[j].color = colors[j];
                }
            }

        }

        cars[i].update();
        if( cars[i].getPosition().distance(destinations[i]) < 5){
            destinations[i] = ofPoint( ofRandom(10,ofGetWidth()-10), ofRandom(10,ofGetHeight()-10) );
        }
    }

    //car1.seek( dest1, 2, 0.04 );
    //car2.seek( dest2, 1, 0.07 );

    // apply repelling force
    /*
    float area = 200;
    if( car1.getPosition().distance( car2.getPosition() ) < area ){
        car1.color = ofColor(255,0,0);
        car2.color = ofColor(255,0,0);

        car1.addRepulsionForce( car2.getPosition(), area,  0.01 );
        car2.addRepulsionForce( car1.getPosition(), area, 0.01 );
        //dest1.addRepulsionForce( dest2.getPosition(), area,  0.01 );
        //dest2.addRepulsionForce( dest2.getPosition(), area, 0.01 );
        dest2.x+=ofRandom(-1,1)*ofRandomf();
        dest2.y+=ofRandom(-1,1)*ofRandomf();
    }else{
        car1.color = ofColor(0,255,0);
        car2.color = ofColor(0,0,255);
    }
    */

    // update physics
    /*
    car1.update();
    car2.update();

    if( car1.getPosition().distance(dest1) < 5){
        dest1 = ofPoint( ofRandomWidth(), ofRandomHeight() );
    }

    if( car2.getPosition().distance(dest2) < 5){
        dest2 = ofPoint( ofRandomWidth(), ofRandomHeight() );
    }
    */
}
Example #10
0
//--------------------------------------------------------------
void testApp::mousePressed(int x, int y, int button){
	downPos = ofPoint(x,y);
}
Example #11
0
//--------------------------------------------------------------
void ofApp::update(){
	
	ofBackground(100,100,100);
	vidGrabber.update();
    
    if ((warping) && (!warperGui.isActive())) {
        
        warperGui.activate();
        warperOutput.activate();
    }
    
    else if (warping) {

        // Actualizamos posiciones
        
        ofPoint dif = ofPoint(outputPos.x, outputPos.y);
        
        float multWidth = (float) secondDisplayWidth / (float) outputWidth;
        float multHeight = (float) secondDisplayHeight / (float) outputHeight;
        ofPoint mult = ofPoint(multWidth, multHeight);
        
        
        
        
        ofPoint tl = warperGui.getCorner(ofxGLWarper::TOP_LEFT);
        ofPoint tr = warperGui.getCorner(ofxGLWarper::TOP_RIGHT);
        ofPoint br = warperGui.getCorner(ofxGLWarper::BOTTOM_RIGHT);
        ofPoint bl = warperGui.getCorner(ofxGLWarper::BOTTOM_LEFT);
        
        warperOutput.setCorner(ofxGLWarper::TOP_LEFT, (tl - dif) * mult);
        warperOutput.setCorner(ofxGLWarper::TOP_RIGHT, (tr - dif) * mult);
        warperOutput.setCorner(ofxGLWarper::BOTTOM_RIGHT, (br - dif) * mult);
        warperOutput.setCorner(ofxGLWarper::BOTTOM_LEFT, (bl - dif) * mult);
        
    }
    
    else if ((!warping) && (warperGui.isActive())) {
        
        warperGui.deactivate();
        warperOutput.deactivate();
        
    }
	
	if (vidGrabber.isFrameNew()){
		
		colorImg.setFromPixels(vidGrabber.getPixels(), camWidth, camHeight);
		
        // ACTUALIZAMOS CANVAS 1
        canvas1.begin();
        ofNoFill();
        ofSetColor(255);
        colorImg.draw(0, 0, canvasWidth, canvasHeight);
        
        if (selection) {

        ofSetColor(255,255,0);
        quadRoi.draw();

            ofSetColor(255,255,0);
        
            for (int i = 0; i < 4; i++) {
                
                if (activeCorners[i]) ofSetColor(255,0,0);
                else ofSetColor(255,255,0);
            
                ofRect(roiCorners[i].x - 5, roiCorners[i].y - 5, 10, 10);

            }
            
        }
        
        ofSetColor(255);
        
        canvas1.end();
        // ------------------------

        
        // ACTUALIZAMOS CANVASWARP
        canvasWarp.begin();
        colorImg.getTextureReference().bind();
        
        glBegin(GL_QUADS);
        glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
        
        for (int i = 0; i < 4; i++) {
            glTexCoord2f(roiCorners[i].x *(float)camWidth/(float)canvasWidth,
                         roiCorners[i].y *(float)camWidth/(float)canvasWidth);
            glVertex2f(destCorners[i].x, destCorners[i].y);
            
        }
        
        glEnd();
        colorImg.getTextureReference().unbind();
        
        canvasWarp.readToPixels(pixels);
        canvasWarp.end();
        // ------------------------
        
        
        // GUARDAMOS WARPEDIMAGE Y PASAMOS A BN Y FILTRAMOS
        warpedImg.setFromPixels(pixels);
        grayImage.setFromColorImage(warpedImg);
        grayImage.threshold(threshold);
        // ------------------------

        
        // ACTUALIZAMOS CANVAS2
        canvas2.begin();
        grayImage.draw(0,0);
        canvas2.end();
        // ------------------------
        
        
        // Pasamos la imagen al fiducial finder
        fidfinder.findFiducials( grayImage );
        
        // Dibujamos el canvas de salida
        output.begin();
        
        ofBackground(0);
        
        if (warping) ofSetColor(255,255,0);
        else ofSetColor(255);
        
        ofNoFill();
        ofRect(1,1,outputWidth-1,outputHeight-1);
        
        ofSetColor(255);
        
        //use this method for the FiducialTracker
        //to get fiducial info you can use the fiducial getter methods
        for (list<ofxFiducial>::iterator fiducial = fidfinder.fiducialsList.begin(); fiducial != fidfinder.fiducialsList.end(); fiducial++) {
            
            int fiducialX = (fiducial -> getX()) * (float) outputWidth / (float) canvasWidth;
            int fiducialY = fiducial -> getY() * (float) outputHeight / (float) canvasHeight;
            float fiducialAngle = fiducial -> getAngleDeg() - 90;
            
            ofRect(0,0,outputWidth, outputHeight);
            ofPushMatrix();
            
            ofTranslate(fiducialX, fiducialY);
            ofRotate(fiducialAngle);
            
            cards[fiducial -> getId()].update(tableWidth, tableHeight);
            cards[fiducial -> getId()].draw();
            ofNoFill();
            ofSetColor(255);
            ofEllipse(0, 0, 20, 20);
            
            string text = "Fid: " + ofToString( fiducial->getId() );
            ofDrawBitmapString( text, 5, 5 );
            ofSetColor(255);
            
            ofPopMatrix();
            
            cout << "fiducial " << fiducial->getId() << " found at ( " << fiducial->getX() << "," << fiducial->getY() << " )" << endl;

        }
        
        output.end();
        
	}
    
    // Actualizamos el quad del ROI de la imagen de entrada
    
    for(int i = 0; i < 4; i++) {
        quadRoi.setVertex(i, roiCorners[i]);

    }
    
	
}
Example #12
0
//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button){
	ofPoint curPos = ofPoint(x,y);
	pos += curPos-downPos;
	downPos = curPos;
    deep.transform(pos, scale);
}
Example #13
0
void Box2dMashEngine::draw()
{

    /* apply physics to the physics objects based on the kinect image */
    tempImg.scaleIntoMe(*(dataHub->grayDiff));
    //tempImg.scaleIntoMe(*(dataHub->grayImage));

    float distance = 0;

    unsigned char *pixels = tempImg.getPixels();
    int circle_index = 0;
    for(int i = 0; i < tempImg.width * tempImg.height; i++) {


            int screen_x = i % tempImg.width / (float)tempImg.width  * ofGetWidth();
            int screen_y = i / tempImg.width / (float)tempImg.height * ofGetHeight();

            // find the next circle representing the first letter of a word
            // and apply physics force to it
            int totalCirclesMoved = 0;
            while(circle_index < circles.size()) {
                if(circles[circle_index].letterInWordIndex == 0) {

                    distance = sqrt(  pow(screen_x - circles[circle_index].letter->col * FONT_SIZE, 2)
                                    + pow(screen_y - circles[circle_index].letter->row * FONT_SIZE, 2));

                    if(distance < 300) {
                        circles[circle_index].addAttractionPoint(ofPoint(screen_x, screen_y),
                                                                 dataHub->strength / distance);
                        circles[circle_index].addDamping(dataHub->damping, dataHub->damping);

                        if(dataHub->bDebug) {
                            ofPushStyle();
                                ofSetColor(0, 255, 0);
                                ofCircle(screen_x, screen_y, 10);
                            ofPopStyle();
                        }
                        totalCirclesMoved++;
                    }
                }
                circle_index++;

                if(totalCirclesMoved > 10) {
                    totalCirclesMoved = 0;
                    break;
                }
            }

            if(circle_index == circles.size()) {
                circle_index = 0;
            }

    }

    if(dataHub->bDebug) {
//        for(int i=0; i<dataHub->messages->size(); i++) {
//            circles[i].draw();
//        }

        for(int i=0; i<circles.size(); i++) {
            circles[i].draw();
        }
        // ofDrawBitmapString(10, ofGetHeight() - 100, "")
        // dataHub->grayDiff->scaleIntoMe(tempImg);
        // dataHub->grayDiff->draw(400, 10);
        // cout << "1:" << tempImg.width << endl;

        tempImg.draw(ofGetWidth() - tempImg.width, 10);

        //cout << "2:" << tempImg.width << endl;
    }
}
void testApp::customDraw ( )
{
    int numUsers = openNIDevice.getNumTrackedUsers();
    // iterate through users
    
    ofColor col1 = ofColor( 0 , 255 , 0 ) ;
    ofColor col2 = ofColor( 0 , 0 , 255 ) ;
    
    /*
 
    for ( int i = 0 ; i < fakeSkeleton.size() ; i++ )
    {
        float ratio = ( float ) i / ( float ) fakeSkeleton.size() ;
        ofPoint p = fakeSkeleton[i] ;
        ofColor c = col1.lerp( col2, ratio ) ;
        ofSetColor( c ) ;
       
        //ofCircle( p.x , p.y , 15 ) ;
        ofDrawBitmapStringHighlight( ofToString(i) , p.x , p.y - 15 ) ;
    }
  */
     //   return ;
    
    
    float xRatio = (float)ofGetWidth() / (float)roiArea.width;
    //xRatio *= .5 ;

    for (int i = 0; i < numUsers; i++)
    {
        ofxOpenNIUser & user = openNIDevice.getTrackedUser(i);
       // user.drawMask();
               
        int numLimbs = user.getNumJoints() ;
        for ( int j = 0 ; j < user.getNumJoints() ; j++ )
        {
            float ratio = ( float ) j / ( float ) user.getNumJoints() ;
            
            ofxOpenNIJoint joint = user.joints[j] ;
            ofPoint p = joint.getProjectivePosition() ;
            p.z = 0 ;
            p.x *= xRatio ;
            p.y *= xRatio ;
            skeleton[j] = p ;
            //cout << " joint[" << j << "] : " << p << endl ;
            ofColor c = col1.lerp( col2, ratio ) ;
            ofSetColor( c ) ;
            ofCircle( p.x , p.y , 15 ) ;
            ofDrawBitmapStringHighlight( ofToString(j) , p.x , p.y - 15 ) ;
        }
        
        //user.drawSkeleton() ;
    }
    
    if ( ofGetElapsedTimef() > ( lastSpawn + spawnDelay ) )
    {
        for ( int i = 0 ; i < spawnPerBeat ; i++ )
        {
            if ( agents.size() < maxParticles )
            {
                Agent a ;
                int index = (int)jointRoutes[0].getRandomTargetIndex() ;
                
                ofPoint randomOffset = ofPoint ( ofRandom ( -25 , 25 ) , ofRandom ( -25 , 25 ) ) ;
                ofPoint p = skeleton[0] + randomOffset ;

                a.setup( p ,  skeleton[index] , index ) ;
                ofColor col = getRandomColor() ;
                a.color = col ; 
                agents.push_back( a )  ;
            }
            
        }
        
        lastSpawn = ofGetElapsedTimef() ; 
        setParticleParams() ; 
    }

}
void ofxColorQuantizer::draw(int x, int y){

	draw(ofPoint(x, y));
}
Example #16
0
//--------------------------------------------------------------
void testApp::mouseDragged(int x, int y, int button)
{
    rm.mouseDragInputPoint(guiIn, ofPoint(x, y));
    rm.mouseDragOutputPoint(guiOut, ofPoint( x, y));
}
Example #17
0
 //--------------------------------------------------------------
 ofPoint Person::getCentroidNormalized(float videoWidth, float videoHeight){
     return ofPoint(centroid.x / videoWidth, centroid.y / videoHeight);
 }
Example #18
0
ofPoint showChar::getPos()
{
	return ofPoint(x,y);
}
Example #19
0
//--------------------------------------------------------------
void testApp::draw(){
    
    ofBackgroundGradient(ofColor(40,40,40), ofColor(20,20,20), OF_GRADIENT_CIRCULAR);

    if(stage != 1){
        gui->toggleVisible();
        gui2->toggleVisible();
    }
    
    if (stage == 0) {
        ofSetColor(255);
        helveticafont30.drawString("DO YOU HAVE SOMETHING TO HIDE?", ofGetWindowWidth()/2-340 , ofGetWindowHeight()/2);
        helveticafont30.drawString("LET THE NSA KNOW WHERE YOU ARE!", ofGetWindowWidth()/2-345 , ofGetWindowHeight()/2 + 45);
        
    } else if (stage == 1) {
        ofSetColor(255);
        helveticafont30.drawString("IS IN NEW YORK", ofGetWindowWidth()/2 - 142 , ofGetWindowHeight()/2);
        helfont15.drawString("Latitude: 40.704196  | Longitude: -74.042358", ofGetWindowWidth()/2 - 132, ofGetWindowHeight()/2 + 25);
        
    } else if (stage == 2) {
        helveticafont30.drawString("THANK YOU FOR YOUR COOPERATION.", ofGetWindowWidth()/2 - 310 , ofGetWindowHeight()/2);
        if(counter >= 140) stage = 0;
    }
    
    if(tracker.getFound()) {
        bFirst = false;
        
        if(counter >= 100 && stage == 0) {
            stage = 1;
        }
        
        if (bSnapshot == true){
            
            unsigned char *camPixels = cam.getPixels();
            img.setFromPixels(camPixels, cam.width, cam.height, OF_IMAGE_COLOR);
            img.crop(tracker.getPosition().x-150, tracker.getPosition().y-150, 300,300);
            string fileName;
//            string dir = "/Users/gusfaria11/Documents/openframeworks_v0.8.0/apps/thesis/PhotoFace/bin/data/img/";
//            string dir = "/Users/gusfaria11/Documents/openframeworks_v0.8.0/apps/thesis/RT_FaceDetect/bin/data/faces/";
            
            string dir = "/Users/gusfaria11/Documents/ofx_v0.8.0/apps/thesis/RT_FaceDetect/bin/data/faces/";
            
//            if(typeStr == ""){
//                fileName = "snapshot_"+ofToString(10000+snapCounter)+".png";
//            } else {
                fileName = typeStr+".png";
//            }

            img.saveImage(dir+fileName);
            sprintf(snapString, "saved %s", fileName.c_str());
            
            //send text to another file.
//            string mydir = "/Users/gusfaria11/Documents/openframeworks_v0.8.0/apps/thesis/RT_FaceDetect/bin/data/train2.txt";
            string mydir = "/Users/gusfaria11/Documents/ofx_v0.8.0/apps/thesis/RT_FaceDetect/bin/data/train2.txt";
//            myfile.open(mydir);
//            string str = "HELLO its me again!\n";
//            cout << str.length() << endl;
//            buffer.allocate(fileName.length());
//            buffer.append(fileName+"\n");
//            myfile.writeFromBuffer(buffer);

//            bool fileWritten = ofBufferToFile(mydir, buffer);
//            buffer.append(fileName+"\n");
//            myfile.close();
            

            
            snapCounter++;
            
            bSnapshot = false;
            bClick = false;
            bFirst = true;

            cam.draw(ofGetWindowWidth(),0);
            buffer = ofBufferFromFile(mydir);
            buffer.append(fileName+"\n");
            ofBufferToFile(mydir, buffer);
            typeStr.clear();
            
            stage = 2;
        }
    }

    if(bDebug){
//DEBUGGING
    ofDrawBitmapStringHighlight("stage: " + ofToString(stage), ofPoint(10,40));
    ofDrawBitmapString(ofToString(counter), ofPoint(10,ofGetWindowHeight()-70));
    ofDrawBitmapString(typeStr, ofPoint(10,ofGetWindowHeight()-50));
    ofPushMatrix();
    ofScale(0.25, 0.25);
    cam.draw(0,0);
    tracker.draw();
    ofPopMatrix();
    }

}
Example #20
0
ofPoint showChar::getSBBsize()
{
	return ofPoint(rect.width,rect.height);
}
void ofApp::setup(){
	ofColor(255); 
	center = ofPoint(ofGetWidth()/2, ofGetHeight()/2);
}
Example #22
0
    
    for (int i=0; i<frames.size();i++){
        frames[i].update();
    }
    
    for (int i=0; i<frames.size(); i++) {
        if (frames[i].getTransition() == Polaroidframe::OUT_WINDOW) {
            frames[i].loadPic(images[ofRandom(images.size())]);
            frames[i].setTransition(Polaroidframe::GET_IN, frames[i].orgPos, ofRandom(14, 15));
        }
    }
    
}


ofPoint centerPos = ofPoint( 1080/4,1920/4);
ofPoint targetPos = ofPoint( 1080/4,1920/4);
//--------------------------------------------------------------
void testApp::draw(){
    
    bool bAnySelected = false;
    ofPoint selectionPoint;
    
    for (int i=0; i<frames.size();i++){
        if (frames[i].isMousepressed()) {
            bAnySelected = true;
            selectionPoint =frames[i].getPos();
        }
    }
    
    if (bAnySelected){
Example #23
0
//--------------------------------------------------------------
void testApp::setup(){
  ofBackground(255,255,255); 
  
  // Image
  bikers.loadImage("bikers.jpg");
  
  quadManager.addQuad(ofPoint(100, 50), ofPoint(300, 100), ofPoint(350, 300), ofPoint(150, 350),
                      ofPoint(100, 500), ofPoint(300, 500), ofPoint(300, 700), ofPoint(100, 700));
  ofxQuad* quad = quadManager.getQuad(0);

  ofxQuadSourceImage* imageSource =  new ofxQuadSourceImage(&bikers);
  quad->setSource(imageSource);
  
  // Video  
  fingerMovie.loadMovie("fingers.mov");
  fingerMovie.play();
  
  quad = quadManager.addQuad();
  quad->setInputPoints(ofPoint(620, 100),
                       ofPoint(fingerMovie.getWidth() + 510, 100),
                       ofPoint(fingerMovie.getWidth() + 510, fingerMovie.getHeight()),
                       ofPoint(620, fingerMovie.getHeight()));
  quad->setOutputPoints(ofPoint(400, 500),
                        ofPoint(600, 520),
                        ofPoint(620, 650),
                        ofPoint(500, 640));
  
  ofxQuadSourceVideo* videoSource = new ofxQuadSourceVideo(&fingerMovie, 510, 0);
  quad->setSource(videoSource );
                        
  ofColor color = ofColor(255, 0, 0);
  quad->setLineColor(color);
  
}
Example #24
0
//--------------------------------------------------------------
void testApp::keyPressed(int key){
   
    if(key == OF_KEY_LEFT){
        for (int i=0; i<frames.size(); i++) {
            frames[i].setTransition(Polaroidframe::GET_OUT,
                                        ofPoint(-frames[i].getWidth()*1.2, ofGetHeight()/2),
                                        ofRandom(14, 20));
        }
    }
    
    if (key == ' ') {
        enable_Debug_Mode = !enable_Debug_Mode;
    }
    
    if (enable_Debug_Mode && frames.size()>0) {
        
        if (key == 'r') {
            int x = 100;
            int y = 200;
            int l = 1;
            frameWidth = 160;
            Polaroidframe  photo;
            frames.push_back(photo);
            frames.back().init(x,y,frameWidth);
            int i = (int)ofRandom(0,images.size()-1);
            frames.back().loadPic(images[i]);
            frames.back().setImageNum(i);
            
            frames.back().loadFont(font);
            frames.back().loadShadow(shadows[0]);
            
            frames.back().setAngle(0);
            frames.back().picName = "Puppy";
            frames.back().cityName = "New York";
            frames.back().setLevel(l);
            frames.back().setStyle(Polaroidframe::POLAROID);
            frames.back().loadShadow(shadows[2]);
            frames.back().bDebug = true;
            
            for (int i=0; i<frames.size()-1; i++) {
                frames[i].bDebug = false;
            }
        }
        
        if(key == 'p')
        {
            XML.clear();
            XML.addChild("PHOTO");
            for (int i=0; i<frames.size(); i++) {
                XML.reset();
                ofXml point;
                point.addChild("val");
                point.setTo("val");
                point.addValue("X", frames[i].getPos().x/ofGetWidth());
                point.addValue("Y", frames[i].getPos().y/ofGetHeight());
                point.addValue("W", frames[i].getWidth()/ofGetWidth());
                point.addValue("L", frames[i].getLevel());
                point.addValue("A", frames[i].getAngle());
                point.addValue("S", frames[i].getStyle());
                point.addValue("I", frames[i].getImageNum());
                
                XML.addXml(point);
            }
            
            XML.save("mySettings.xml");
            cout<< "settings saved to xml!" <<endl;
        }
        
        
       

        if (key == 'a') {
            
            Angle --;
        }
        
        if (key == 'd') {
            
            Angle ++;
        }
        
        
        if (key == 's') {
            
            frameWidth -=10;
        }
        
        if (key == 'w') {
            
            frameWidth+=10;
        }
        
        if (key == '1') {
            
            frames.back().setLevel(1);
            

        }
        
        if (key == '2') {
            
            frames.back().setLevel(2);
            
        }
        
        if (key == '3') {
            
            frames.back().setLevel(3);
            
        }
        
        if (key == '4') {
            
            frames.back().setLevel(4);
            
        }
        
        if (key == 'e') {
            
            frameStyle++;
            if (frameStyle >3)frameStyle =0;
            
            if (frameStyle == 0){
                frames.back().setStyle(Polaroidframe::NO_FRAME_1);
                frames.back().loadShadow(shadows[1]);
            }
            if (frameStyle == 1){
                frames.back().setStyle(Polaroidframe::NO_FRAME_2);
                frames.back().loadShadow(shadows[0]);
                
            }
            if (frameStyle == 2) {
                frames.back().setStyle(Polaroidframe::FRAME);
                frames.back().loadShadow(shadows[1]);
                
            }
            if (frameStyle == 3){
                frames.back().setStyle(Polaroidframe::POLAROID);
                frames.back().loadShadow(shadows[2]);
            }
        }
        
        if (key == 'z') {

            frames.erase(frames.end());
            
        }
        
        if (key == 'q') {
            
            shadowNum ++;
            if (shadowNum > shadows.size()-1) {
                shadowNum = 0;
            }
            frames.back().loadShadow(shadows[shadowNum]);
            
        }

    }
}
Example #25
0
void testApp::draw() {
	// clear depth buffer (but not color buffer)
	glClear(GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	
	
	// enable blending
	glEnable(GL_BLEND);
	
	// choose semi-transparent black color
	myObj.setColor(0, 0, 0, 0.05f);
	
	// draw a black semi-transparent rectangle across whole screen to fade it out a bit
	myObj.drawRect(0, 0, ofGetWidth(), ofGetHeight());
	
	// disable blending
	glDisable(GL_BLEND);
	
	
	// get current time (could use ofGetElapsedTimef() but I DONT want it to be fps independant
	// cos when I'm saving frames and it's running slow I want it to behave the same
	float curTime = ofGetFrameNum() * 1.0f/60.0f;
	
	// choose start rotation based on curTime
	float theta = sin(curTime * 0.17f) * TWO_PI;
	
	// set start position offset from center of screen
	float startOffset = -50.0f * sin(curTime * 0.09f);
	pos.set(ofGetWidth()/2 + cos(theta) * startOffset, ofGetHeight()/2 + sin(theta) * startOffset, 0);
	
	// begin a triangle strip
	myObj.begin(GL_TRIANGLE_STRIP);
	for(int i=0; i<5000; i++) {
		// calculate and set colors
		// RGB components modulate sinusoidally, frequency increases with iteration count
		myObj.setColor(sin(curTime * 0.8f + i * 0.0011f) * 0.5f + 0.5f, sin(curTime * 0.7f + i * 0.0013f) * 0.5f + 0.5f, sin(curTime * 0.3f + i * 0.0017f) * 0.5f + 0.5f);
		
		// do some maths to calculate vertex positions
		// modulate theta (offset rotation) sinusoidally, frequency increases with iteration count
		// use two modulations with different frequencies to create complex harmonic motion 
		theta += sin(curTime * 0.1f + i * 0.00062f) * 2.0f * DEG_TO_RAD * i * 0.0004 + sin(curTime*0.2f + i * 0.0009f) * 3.0f * DEG_TO_RAD;
		float cos_t = cos(theta);
		float sin_t = sin(theta);
		
		// x, y position cumulatively rotates
		// z position modulates sinusoidally, frequency increases with iteration count
		pos += ofPoint(cos_t, sin_t, sin(curTime * 0.5f + i*0.002f) * 0.5);
		
		// send vertex data to myObj
		myObj.addVertex(pos.x, pos.y, pos.z);
		
		// do some math to calculate another vertex position
		// perpendicular to rotation
		// thickness modulates sinusoidally, frequency increases with iteration count
		// also modulation frequency sinusoidally
		ofPoint pos2 = pos + ofPoint(sin_t, -cos_t) * ofMap(sin(curTime * 0.4f * ( 1.0f + i * 0.001f) + i * 0.06f + sin(i*0.001f) * 0.2f), -1, 1, 5, 10 +  i * 0.01f);
		
		// place second vertex (can also pass pointer (array) to coordinates)
		myObj.addVertex2v(pos2.v);
	}
	
	// end vertices and draw to screen
	myObj.end();
	
	
	// draw fps
	glDisable(GL_DEPTH_TEST);
	glColor4f(0, 0, 0, 1);
	ofRect(0, 0, ofGetWidth(), 20);
	
	glColor4f(1, 1, 1, 1);
	ofDrawBitmapString(ofToString(ofGetFrameRate()), 10, 10);
}
Example #26
0
void Frostscape::update(){
	if(resetLines){
		resetLines = false;
		lines[0].clear();
		lines[1].clear();
		linesOffset[0].clear();
		linesOffset[1].clear();
		linesFreezePoints.clear();
	}
	if(addingLines){
		for(int i=0;i<2;i++){
			if(blob(cam)->numPersistentBlobs() >= i+1){
				ofxPoint2f p = projection()->convertToFloorCoordinate(blob(cam)->persistentBlobs[i].getLowestPoint());
				if(lines[i].size() == 0 || p.distance(lines[i].back()) > ofRandom(0.05, 4)){
					lines[i].push_back(p);
					linesOffset[i].push_back(0.3*linesSpeed*ofxVec2f(ofRandom(-0.05, 0.05),ofRandom(-0.05, 0.05)));
				}
			}
		}		
	}
	//Freeze lines
	if(freezeLines > 0){
		for(int i=0;i<2;i++){
			if(ofRandom(0, 1) < 0.03*freezeLines && lines[i].size() > 0){
				linesFreezePoints.push_back(lines[i][floor(ofRandom(0, lines[i].size()-1))]);
			}
		}
	}
	
	for(int i=0;i<linesFreezePoints.size();i++){
		motor.addFreezePoint(linesFreezePoints[i], 0.03);
	}
	
	invert = false;
	motor.centerBreakRate =  Frostscape::slider1;
	motor.bodyBreakRate =  Frostscape::slider2;	
	motor.decreaseRate = Frostscape::slider5*10;
	motor.expandRate = Frostscape::slider6;
	if(invert){
		ofColor c;
		c.r = 0;
		c.g = 0;
		c.b = 0;
		motor.setColor(c);
	} else{
		ofColor c;
		motor.setColor(c);
	}
	
	if(sideFreeze > 0){
		float n = 3.0;
		for (int i=0;i<n; i++) {
			motor.addFreezePoint(ofPoint(0,i/n), sideFreeze);
		}
		for (int i=0;i<n; i++) {
			motor.addFreezePoint(ofPoint(projection()->getFloor()->aspect,i/n), sideFreeze);
		}
		for (int i=0;i<n; i++) {
			motor.addFreezePoint(ofPoint(projection()->getFloor()->aspect*i/n,0), sideFreeze);
			motor.addFreezePoint(ofPoint(projection()->getFloor()->aspect*i/n,1), sideFreeze);
			
		}
	}
	/*if(columnFreeze > 0.1){
	 for(int i=0;i<3;i++){
	 motor.addFreezePoint(projection()->getColumnCoordinate(i), columnFreeze);
	 
	 }
	 } else if(columnFreeze < -0.1){
	 for(int i=0;i<3;i++){
	 motor.addBodyCenter(projection()->getColumnCoordinate(i));
	 
	 }
	 }*/
	
	
	for(int i=0;i<3;i++){
		if(columnFreeze[i] > 0){
			//	int i=1;
			columnParticleX[i] += 0.003*60.0/ofGetFrameRate();
			columnParticlePos[i] += (sin(columnParticleX[i]*TWO_PI-HALF_PI)+1)*(0.003*60.0/ofGetFrameRate());	
			if(columnParticlePos[i] > 0  && columnParticlePos[i] < 5.0){
				//				cout<<"add "<<i<<"  "<<columnFreeze[i]<<endl;
				motor.addFreezePoint(projection()->getColumnCoordinate(i), columnFreeze[i]*0.01);	
			}
		} else {
			columnParticleX[i] = 0;
			columnParticlePos[i] = 0;	
		}
	} 

	for(int i=0;i<MIN(blob(cam)->numPersistentBlobs(),6);i++){
		PersistentBlob * pb = &blob(cam)->persistentBlobs[i];
		vector<ofxCvBlob> b = blob(cam)->persistentBlobs[i].blobs;
		ofxVec2f r = projection()->convertToCoordinate(projection()->getFloor(), pb->centroid);			
		
		motor.addBodyCenter(r);
		for(int g=0;g<b.size();g++){
			for(int u=0;u<b[g].nPts;u++){
				ofxVec2f r = projection()->convertToCoordinate(projection()->getFloor(), ofxVec2f(b[g].pts[u].x,b[g].pts[u].y));			
				
				motor.addBodyPoint(r);
			}
		}
		
	}
	
	/*
	 for(int i=0;i<MIN(blob(cam)->numPersistentBlobs(),2);i++){
	 PersistentBlob * pb = &blob(cam)->persistentBlobs[i];
	 //		vector<ofxCvBlob> b = blob(cam)->persistentBlobs[i].blobs;
	 ofxVec2f r = projection()->convertToCoordinate(projection()->getFloor(), pb->centroid);			
	 
	 motor.addFreezePoint(r,0.1);
	 
	 }
	 //*/
	
	motor.update();
}
Example #27
0
//--------------------------------------------------------------
void testApp::setup()
{
    int tabBarWidth = 80;
    
    // ---
    guiTabBar = new ofxUITabBar();
    guiTabBar->setWidth(tabBarWidth);
    guiTabBar->setColorFill(ofxUIColor(200));
    guiTabBar->setColorFillHighlight(ofxUIColor(255));
    guiTabBar->setColorBack(ofxUIColor(255, 20, 20, 150));
    
    // ---
    ofEnableTextureEdgeHack();
    middle.loadImage("slidertrack.png");
    middle.getTextureReference().setTextureWrap(GL_REPEAT, GL_REPEAT);
    middle.update();
    
	ofEnableSmoothing(); 
    ofSetCircleResolution(60);
    
    red = 100; blue = 100; green = 100;
	
	float dim = 24; 
	float xInit = OFX_UI_GLOBAL_WIDGET_SPACING; 
    float length = 320-xInit; 
	
    drawPadding = false;
    
    // ---
    ofxUICanvas* guiA = new ofxUICanvas(tabBarWidth, 0, length+xInit, 100);
    guiA->setName("Main");
    guiA->setPosition(tabBarWidth, 0);
    guiA->setColorFill(ofxUIColor(200));
    guiA->setColorFillHighlight(ofxUIColor(255));
    guiA->setColorBack(ofxUIColor(20, 20, 20, 150));
    {
        guiA->addLabel("Tab Bar");
        guiA->addSpacer();
        guiA->addButton("SAVE", false);
        guiA->addButton("LOAD", false);
    }
    
    ofAddListener(guiA->newGUIEvent,this,&testApp::guiEvent);
    guiTabBar->addCanvas(guiA);
    
    // ---
    guiB = new ofxUICanvas(tabBarWidth, 0, length+xInit, ofGetHeight());
	guiB->setName("Tab 2");
    guiB->addWidgetDown(new ofxUILabel("SLIDER WIDGETS", OFX_UI_FONT_LARGE));         
    guiB->addSpacer(length-xInit, 1); 
    guiB->addFPSSlider("FPS SLIDER", length-xInit, dim*.25, 1000);
    guiB->addSpacer(length-xInit, 1); 
	guiB->addWidgetDown(new ofxUILabel("NORMAL SLIDER", OFX_UI_FONT_MEDIUM)); 	
    guiB->addSlider("RED", 0.0, 255.0, red, length-xInit,dim);
    guiB->addSpacer(length-xInit, 1); 
	guiB->addWidgetDown(new ofxUILabel("MINIMAL SLIDER", OFX_UI_FONT_MEDIUM)); 	
    guiB->addWidgetDown(new ofxUIMinimalSlider(length-xInit, 0.0, 255.0, green, "GREEN", OFX_UI_FONT_MEDIUM));
    guiB->addSpacer(length-xInit, 1); 
	guiB->addWidgetDown(new ofxUILabel("BILABEL SLIDER", OFX_UI_FONT_MEDIUM)); 	    
    guiB->addWidgetDown(new ofxUIBiLabelSlider(length-xInit, 0.0, 255.0, blue, "BLUE", "LESS BLUE", "MORE BLUE", OFX_UI_FONT_MEDIUM));
    guiB->addSpacer(length-xInit, 1); 
    guiB->addWidgetDown(new ofxUILabel("VERTICAL SLIDERS", OFX_UI_FONT_MEDIUM));     
    guiB->addSlider("1", 0.0, 255.0, 100.0, dim,80);
    guiB->setWidgetPosition(OFX_UI_WIDGET_POSITION_RIGHT);
	guiB->addSlider("2", 0.0, 255.0, 150.0, dim, 80);
	guiB->addSlider("3", 0.0, 255.0, 200.0, dim, 80);
	guiB->addSlider("4", 0.0, 255.0, 250.0, dim, 80);
	guiB->setWidgetPosition(OFX_UI_WIDGET_POSITION_DOWN);
    guiB->addSpacer(length-xInit, 1);     
    guiB->addWidgetDown(new ofxUILabel("RANGE SLIDER", OFX_UI_FONT_MEDIUM)); 
	guiB->addWidgetDown(new ofxUIRangeSlider(length-xInit,dim, 0.0, 255.0, 50.0, 100.0, "RSLIDER")); 
    guiB->addSpacer(length-xInit, 1); 
	guiB->addWidgetDown(new ofxUILabel("ROTARY SLIDER", OFX_UI_FONT_MEDIUM));
    guiB->addWidgetDown(new ofxUIRotarySlider(dim*2.0, 0.0, 100.0, 25.0, "CSLIDER 2")); 
    guiB->addSpacer(length-xInit, 1);     
	guiB->addWidgetDown(new ofxUILabel("2D PAD", OFX_UI_FONT_MEDIUM)); 
	guiB->addWidgetDown(new ofxUI2DPad(length-xInit,80, ofPoint((length-xInit)*.5,80*.5), "PAD")); 	
    guiB->addSpacer(length-xInit, 1);     
	guiB->addWidgetDown(new ofxUILabel("CIRCLE SLIDER", OFX_UI_FONT_MEDIUM)); 
	guiB->addWidgetDown(new ofxUICircleSlider(dim*2, 0.0, 255.0, green, "GREEN", OFX_UI_FONT_MEDIUM));
    guiB->addSpacer(length-xInit, 1);     
	guiB->addWidgetDown(new ofxUILabel("IMAGE SLIDER", OFX_UI_FONT_MEDIUM)); 
    guiB->addWidgetDown(new ofxUIImageSlider(length-xInit, 42, 0.0, 255.0, red, "slider.png", "IMAGE SLIDER"));
    guiB->setColorBack(ofColor(255,100));
    
    ofAddListener(guiB->newGUIEvent,this,&testApp::guiEvent);
    guiTabBar->addCanvas(guiB);
    
	ofBackground(red, green, blue);
    
    guiTabBar->loadSettings("settings/", "ui-");
}
Example #28
0
void ofxUICanvas::loadSpecificWidgetData(ofxUIWidget *widget,
                                         ofxXmlSettings *XML)
{
    int kind = widget->getKind();        
    switch (kind) 
    {
        case OFX_UI_WIDGET_TOGGLE:
        {
            ofxUIToggle *toggle = (ofxUIToggle *) widget; 
            int value = XML->getValue("Value", (toggle->getValue() ? 1 : 0), 0);                             
            toggle->setValue((value ? 1 : 0)); 
        }
            break;
            
        case OFX_UI_WIDGET_BILABELSLIDER:    
        case OFX_UI_WIDGET_MINIMALSLIDER:
        case OFX_UI_WIDGET_SLIDER_H:
        case OFX_UI_WIDGET_SLIDER_V:
        {
            ofxUISlider *slider = (ofxUISlider *) widget; 
            float value = XML->getValue("Value", slider->getScaledValue(), 0);            
            slider->setValue(value); 
        }
            break;
            
        case OFX_UI_WIDGET_RSLIDER_H:
        case OFX_UI_WIDGET_RSLIDER_V:
        {
            ofxUIRangeSlider *rslider = (ofxUIRangeSlider *) widget; 
            float valueHigh = XML->getValue("HighValue", rslider->getScaledValueHigh(), 0); 
            float valueLow = XML->getValue("LowValue", rslider->getScaledValueLow(), 0); 
            rslider->setValueHigh(valueHigh);
            rslider->setValueLow(valueLow);
        }
            break;
            
        case OFX_UI_WIDGET_NUMBERDIALER:
        {
            ofxUINumberDialer *numdialer = (ofxUINumberDialer *) widget; 
            float value = XML->getValue("Value", numdialer->getValue(), 0);             
            numdialer->setValue(value);                 
        }
            break;
            
        case OFX_UI_WIDGET_2DPAD:
        {
            ofxUI2DPad *pad = (ofxUI2DPad *) widget; 
            float valueX = XML->getValue("XValue", pad->getScaledValue().x, 0); 
            float valueY = XML->getValue("YValue", pad->getScaledValue().y, 0); 
            pad->setValue(ofPoint(valueX, valueY)); 
        }
            break;
            
        case OFX_UI_WIDGET_TEXTINPUT:
        {
            ofxUITextInput *textInput = (ofxUITextInput *) widget; 
            string value = XML->getValue("Value", textInput->getTextString(), 0);             
            textInput->setTextString(value); 
        }
            break;
            
        case OFX_UI_WIDGET_LABELTOGGLE:
        {
            ofxUILabelToggle *ltoggle = (ofxUILabelToggle *) widget; 
            int value = XML->getValue("Value", (ltoggle->getValue() ? 1 : 0), 0);                         
            ltoggle->setValue((value ? 1 : 0)); 
        }
            break;
            
        case OFX_UI_WIDGET_IMAGETOGGLE:
        {
            ofxUIImageToggle *itoggle = (ofxUIImageToggle *) widget; 
            int value = XML->getValue("Value", (itoggle->getValue() ? 1 : 0), 0);                        
            itoggle->setValue((value ? 1 : 0)); 
        }
            break;
            
        case OFX_UI_WIDGET_ROTARYSLIDER:
        {
            ofxUIRotarySlider *rotslider = (ofxUIRotarySlider *) widget;
            float value = XML->getValue("Value", rotslider->getScaledValue(), 0);            
            rotslider->setValue(value); 
        }
            break;
            
        default:
            break;
    }        
}
Example #29
0
ofPoint ofxConfig::getVector(int id)
{
	return ofPoint(this->get(id,0), this->get(id,1),this->get(id,2));
}
//--------------------------------------------------
ofPoint ofxARToolkitPlus::getDetectedMarkerCenter(int markerIndex) {
	ARToolKitPlus::ARMarkerInfo marker = tracker->getDetectedMarker(markerIndex);
	return ofPoint(marker.pos[0], marker.pos[1]);
}