//-------------------------------------------------------------- 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 ; }
//-------------------------------------------------------------- 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; }
//-------------------------------------------------------------- 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){ } }
//------------------------------------------------ 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()); }
//-------------------------------------------------------------- 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; }
//-------------------------------------------------------------- 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() ); } */ }
//-------------------------------------------------------------- void testApp::mousePressed(int x, int y, int button){ downPos = ofPoint(x,y); }
//-------------------------------------------------------------- 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]); } }
//-------------------------------------------------------------- void testApp::mouseDragged(int x, int y, int button){ ofPoint curPos = ofPoint(x,y); pos += curPos-downPos; downPos = curPos; deep.transform(pos, scale); }
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)); }
//-------------------------------------------------------------- void testApp::mouseDragged(int x, int y, int button) { rm.mouseDragInputPoint(guiIn, ofPoint(x, y)); rm.mouseDragOutputPoint(guiOut, ofPoint( x, y)); }
//-------------------------------------------------------------- ofPoint Person::getCentroidNormalized(float videoWidth, float videoHeight){ return ofPoint(centroid.x / videoWidth, centroid.y / videoHeight); }
ofPoint showChar::getPos() { return ofPoint(x,y); }
//-------------------------------------------------------------- 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(); } }
ofPoint showChar::getSBBsize() { return ofPoint(rect.width,rect.height); }
void ofApp::setup(){ ofColor(255); center = ofPoint(ofGetWidth()/2, ofGetHeight()/2); }
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){
//-------------------------------------------------------------- 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); }
//-------------------------------------------------------------- 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]); } } }
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); }
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(); }
//-------------------------------------------------------------- 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-"); }
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; } }
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]); }