Example #1
0
//--------------------------------------------------------------
void testApp::draw(){
    ofBackground(background);
    float windowWidth = ofGetWidth();
    float windowHeight = ofGetHeight();
    
    //draw the playback over the top for debugging for now
    ofSetColor(ofColor::white);
    
    ofPushMatrix();
    
    //openNIPlayer.drawDebug(0, 0);
    
    if(drawVideo){
        openNIPlayer.drawImage(0, 0, windowWidth, windowHeight);
    }
    
    if(drawDepth){
        openNIPlayer.drawDepth(0, 0, windowWidth, windowHeight);
    }
    
    ofPopMatrix();
    
	ofEnableBlendMode(OF_BLENDMODE_ALPHA);
    
    ofSetColor(foreground);
    
    ofColor theColourToUse = foreground;
    
    ofFill();
    
    if(allPointsTracking){
        for(int i=0; i< (int) bodyCharts.size(); i++){
            bodyCharts[i].draw(0,0,windowWidth,windowHeight, lineScale, lineAlpha, lineWidth, fadeHistory, theColourToUse);
        }
    }
    
    if(allPointsVerticalLines){
        for(int i=0; i< (int) bodyCharts.size(); i++){
            bodyCharts[i].drawVerticalLines(0,0,windowWidth,windowHeight, lineScale, lineAlpha, lineWidth, fadeHistory, theColourToUse);
        }
    }
    
    if(allPointsHorizontalLines){
        for(int i=0; i< (int) bodyCharts.size(); i++){
            bodyCharts[i].drawHorizontalLines(0, 0, windowWidth, windowHeight, lineScale, lineAlpha, lineWidth, fadeHistory, theColourToUse);
        }
    }
    
    if(allPointsCircles){
        for(int i=0; i< (int) bodyCharts.size(); i++){
            bodyCharts[i].drawCircles(0, 0, windowWidth, windowHeight, lineScale, lineAlpha, lineWidth,fadeHistory, theColourToUse);
        }
    }
    
    if(allPointsRibbon){
        for(int i=0; i< (int) bodyCharts.size(); i++){
            bodyCharts[i].drawRibbon(0, 0, windowWidth, windowHeight, lineAlpha, fadeHistory, theColourToUse);
        }
    }
    
    if(hipLine){
        hipChart.draw(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, fadeHistory, theColourToUse);
    }
    
    if(shoulderLine){
        shoulderChart.draw(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, fadeHistory, theColourToUse);
    }
    
    if(handsLine){
        handsChart.draw(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, fadeHistory, theColourToUse);
    }
    
    if(hipLineToEdge){
        hipChart.drawToEdgeOfScreen(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, theColourToUse);
    }
    
    if(shoulderLineToEdge){
        shoulderChart.drawToEdgeOfScreen(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, theColourToUse);
    }
    
    if(handsLineToEdge){
        handsChart.drawToEdgeOfScreen(0, 0, windowWidth, windowHeight, lineAlpha, lineWidth, theColourToUse);
    }
    
	// auto draw?
	// should the gui control hiding?
	if( !bHide){
		gui.draw();
	}
}
Example #2
0
//--------------------------------------------------------------
void ofApp::draw() {
	image.draw(0, 0);
    
    //vidGrabber.draw(20, 20);
	ofNoFill();
	for (int i = 0; i < haarFinderLinks.blobs.size(); i++) {
		ofRectangle blobBoundingRect = haarFinderLinks.blobs[i].boundingRect;
		if(blobBoundingRect.width < 150 && blobBoundingRect.width > 100){
			ofImage oog = beeld;
			oog.crop(blobBoundingRect.x, blobBoundingRect.y, blobBoundingRect.width, blobBoundingRect.height);
			for (int i = 0; i < 40; i++) {
				switch (i)
				{
				case 0:
					ofEnableAlphaBlending();
					ofPushMatrix();
					ofTranslate(250, 500, 0);
					ofRotate(80);
					ofSetColor(255, 255, 255, transperantie);
					oog.draw(0, 0);
					ofPopMatrix();
					ofDisableAlphaBlending();
					break;
				case 1:
					//oog.draw(100, 100);
					break;
				case 2:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(260, 600, 0);
                        ofRotate(50);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 3:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(320, 690, 0);
                        ofRotate(25);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 4:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(400, 740, 0);
                        ofRotate(5);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 5:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(510, 750, 0);
                        ofRotate(-5);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 6:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(600, 750, 0);
                        ofRotate(-35);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 7:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(700, 700, 0);
                        ofRotate(-65);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 8:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(760, 620, 0);
                        ofRotate(-90);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 9:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(770, 510, 0);
                        ofRotate(-100);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 10:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(750, 400, 0);
                        ofRotate(-125);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 11:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(700, 320, 0);
                        ofRotate(-145);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 12:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(620, 260, 0);
                        ofRotate(-170);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 13:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(510, 240, 0);
                        ofRotate(-190);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 14:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(410, 255, 0);
                        ofRotate(-210);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 15:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(320, 310, 0);
                        ofRotate(-230);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                    case 16:
                        ofEnableAlphaBlending();
                        ofPushMatrix();
                        ofTranslate(260, 390, 0);
                        ofRotate(-265);
                        ofSetColor(255, 255, 255, transperantie);
                        oog.draw(0, 0);
                        ofPopMatrix();
                        ofDisableAlphaBlending();
                        break;
                        
                        break;
				}
			
				}
			}
	}
}
Example #3
0
//--------------------------------------------------------------
void testApp::drawGeometry(){
	
    float pointAlpha = timeline.getValue("Point Alpha");
	float pointSize = timeline.getValue("Point Size");
    float wireAlpha = timeline.getValue("Wireframe Alpha");
	float thickness = timeline.getValue("Wireframe Thickness");
	
	float particleAlpha = timeline.getValue("particle fade");
//	float particleSize = timeline.getValue("particle size");

	
	glEnable(GL_LINE_SMOOTH);
	glEnable(GL_POINT_SMOOTH);
	
	player.getVideoPlayer()->getTextureReference().bind();
	
	ofPushMatrix();
	ofPushStyle();
	ofScale(1,-1,1);
	
	ofPushMatrix();
	ofTranslate(timeline.getValue("x offset"), 0, timeline.getValue("z offset"));
	ofEnableBlendMode(OF_BLENDMODE_SCREEN);

	if(drawWireframe && wireAlpha > 0){

		glPushAttrib(GL_ALL_ATTRIB_BITS);
		glEnable(GL_CULL_FACE);

		glCullFace(GL_FRONT);

		ofTranslate(0,0,-.5);
		ofSetColor(255*wireAlpha);
		thickness *= thickness;
		ofSetLineWidth(thickness);
		meshBuilder.getMesh().drawWireframe();
		
		glPopAttrib();
	}
	
	if(drawPointcloud && pointAlpha > 0){

		ofTranslate(0,0,-.5);
		ofSetColor(255*pointAlpha);
		meshBuilder.getMesh().disableColors();
		
		meshBuilder.getMesh().setMode(OF_PRIMITIVE_POINTS);
		glPointSize(pointSize*pointSize);
		meshBuilder.getMesh().draw();
		meshBuilder.getMesh().setMode(OF_PRIMITIVE_TRIANGLES);
	
		meshBuilder.getMesh().enableColors();
	}
	
	ofPopMatrix();
	
	if(drawParticles){
		
		cloudShader.begin();
		particleRenderer.mesh.drawVertices();
		cloudShader.end();
	}
	
	player.getVideoPlayer()->getTextureReference().unbind();
	
	if(justLoadedNewScene){
		cout << "RENDERED FIRST FRAME OF " << player.getVideoPlayer()->getCurrentFrame() << endl;
		justLoadedNewScene = false;
	}
	
	ofPopStyle();
	ofPopMatrix();
}
Example #4
0
//--------------------------------------------------------------
void testApp::draw() {
	
	    ofBackground(255, 255, 255);
		
		back.draw(0,0,ofGetWidth(),ofGetHeight());
	    
		
		//cbot01.draw(0, 0);
		
		
		if (b02==true) {
			back002.draw(0,0, ofGetWidth(),ofGetHeight());
			
			
			svg02.load("bot04.svg");
			
			ofPath path02;
			path02 = svg02.getPathAt(0);
			
			ofPolyline line02 = path02.getOutline()[0];
			polyLine.clear();
			
			cout << line02.getVertices().size() << endl;
			for (int i = 0; i < line02.getVertices().size(); i++){
				polyLine.addVertex(line02.getVertices()[i]);
			}
			
			polyLine.setPhysics(0.0, 0.5, 0.5);
			polyLine.create(box2d.getWorld());
			
			
		}
		
		if (b03==true) {
			back003.draw(0,0, ofGetWidth(),ofGetHeight());
			
			
			svg03.load("bot02.svg");
			
			
			ofPath path03;
			path03 = svg03.getPathAt(0);
			
			ofPolyline line03 = path03.getOutline()[0];
			polyLine.clear();
			
			cout << line03.getVertices().size() << endl;
			for (int i = 0; i < line03.getVertices().size(); i++){
				polyLine.addVertex(line03.getVertices()[i]);
			}
			
			polyLine.setPhysics(0.0, 0.5, 0.5);
			polyLine.create(box2d.getWorld());
			
			
		}
		
		if (b04==true) {
			back004.draw(0,0, ofGetWidth(),ofGetHeight());
			
			
			svg04.load("bot03.svg");
			
			
			ofPath path04;
			path04 = svg04.getPathAt(0);
			
			ofPolyline line04 = path04.getOutline()[0];
			polyLine.clear();
			
			cout << line04.getVertices().size() << endl;
			for (int i = 0; i < line04.getVertices().size(); i++){
				polyLine.addVertex(line04.getVertices()[i]);
			}
			
			polyLine.setPhysics(0.0, 0.5, 0.5);
			polyLine.create(box2d.getWorld());
			
			
		} 
		
		if (b05==true) {
			ofSetColor(255);
			back.draw(0,0, ofGetWidth(),ofGetHeight());
			
			
			svg.load("bot01.svg");
			
			
			ofPath path;
			path = svg.getPathAt(0);
			
			ofPolyline line = path.getOutline()[0];
			polyLine.clear();
			
			cout << line.getVertices().size() << endl;
			for (int i = 0; i < line.getVertices().size(); i++){
				polyLine.addVertex(line.getVertices()[i]);
			}
			
			polyLine.setPhysics(0.0, 0.5, 0.5);
			polyLine.create(box2d.getWorld());
			
			
		} 
		
		
		
		
		
		
		// circle with animals
		for(int i=0; i<circles.size(); i++) {
			ofNoFill();
			circles[i].draw(); 
			
		}
		
		
		// testing boxes
		
		/*for(int i=0; i<boxes.size(); i++) {
		 ofFill();
		 
		 SoundData * data = (SoundData*)boxes[i].getData();
		 if(data && data->bHit) ofSetHexColor(0xff0000);
		 else ofSetHexColor(0x4ccae9);
		 //ofEnableAlphaBlending();
		 //ofSetColor(255,0,0,0);
		 //ofSetHexColor(0xe63b8b);
		 //	boxes[i].draw();
		 
		 }*/
		
		
		// animal boxes
		/*for(int i=0; i<boxes.size(); i++) {
		 //ofFill();
		 SoundData * data = (SoundData*)boxes[i].getData();
		 //ofEnableAlphaBlending();
		 //ofSetColor(R,G,B);
		 //ofSetHexColor(0xe63b8b);
		 //	boxes[i].draw();
		 
		 }*/
		
		
		for(int i=0; i<images.size(); i++) {
			
		    
			ofSetColor(circles[i].color.r, circles[i].color.g, circles[i].color.b);
			ofSetRectMode(OF_RECTMODE_CENTER);
			
		    ofPushMatrix();
	        
			ofTranslate(circles[i].getPosition().x, circles[i].getPosition().y);
			ofRotateZ(circles[i].getRotation());
		    images[i].draw(0,0);
			
		    ofSetRectMode(OF_RECTMODE_CORNER);
		    
		    ofPopMatrix();
			
			
		}
		
		
		
		/*for(int i=0; i<circles.size(); i++) {
		 ofFill();
		 SoundData * data = (SoundData*)circles[i].getData();
		 
		 if(data && data->bHit) ofSetHexColor(0xff0000);
		 else ofSetHexColor(0x4ccae9);
		 
		 
		 circles[i].draw();
		 }*/
		
		//ofSetColor(255,255,130);
		//	
		//	ofDrawBitmapString("drawing mode: inward", 50, 90);
		//		
		//	ofDrawBitmapString("drawing mode: outward", 50, 120);
		//	
		//	ofDrawBitmapString("drawing mode: clockwise", 50, 150);
		//	
		//	ofDrawBitmapString("drawing mode: counter-clockwise", 50, 170);
		//		
		//		
		//			
		//			
		//	
		//	string info = "";
		//	info += "FPS: "+ofToString(ofGetFrameRate(), 1)+"\n";
		//	info += "FPS: "+ofToString(R, 1)+"\n";
		//	info += "FPS: "+ofToString(G, 1)+"\n";
		//	info += "FPS: "+ofToString(B, 1)+"\n";
		//	ofSetHexColor(0x444342);
		//	ofDrawBitmapString(info, 30, 30);
		//		
		
		
		/*for(int i=0; i<customParticles.size(); i++) {
		 customParticles[i].draw();
		 }*/
		
		ofNoFill();
		//ofSetHexColor(0x444342);
		ofEnableAlphaBlending();
		ofSetColor(255, 0, 255,0);
		ofEnableAlphaBlending();
		//if(drawing.size()==0) 
		polyLine.draw();
		//else drawing.draw();
		
		
		
		//text
		//ofSetColor(80);
		
		//ofRect(20,20, 300, 800);
		
		
		
		ofSetColor(0, 0, 0);
	ofPushMatrix();
	ofTranslate(1005,550);
	ofRotateZ(-12);
	//font.drawString(typeStr, 0,0);
	
	ofDrawBitmapString(typeStr, 0,0);
	ofPopMatrix();	
		
		
		
	
	ofSetColor(255, 255, 255);//****important
		
	
		
	if (startscreen) {
		frontPage.draw(0, 0, ofGetWidth(),ofGetHeight());
	}
	
	
	
	
}
//-------------------------------
void ofxControlPanel::draw(){
    if( hidden ) return;

    ofPushStyle();
    ofEnableAlphaBlending();

        float panelH = boundingBox.height;
        if( minimize ){
            panelH = topBar.height;
        }

        glPushMatrix();
            glTranslatef(boundingBox.x, boundingBox.y, 0);
            //draw the background
            ofFill();
            glColor4fv(bgColor.getColorF());
            ofRect(0, 0, boundingBox.width, panelH);

            //draw the outline
            ofNoFill();
            glColor4fv(outlineColor.getColorF());
            ofRect(0, 0, boundingBox.width, panelH);
            ofLine(0, topBar.height, boundingBox.width, topBar.height);
        glPopMatrix();

        ofRect(minimizeButton.x, minimizeButton.y, minimizeButton.width, minimizeButton.height);

        ofPushStyle();
            ofFill();

            if( saveDown )glColor4fv(fgColor.getSelectedColorF());
            else glColor4fv(fgColor.getColorF());

            ofRect(saveButton.x, saveButton.y, saveButton.width,saveButton.height);
            ofSetColor(255, 255, 255);
		if(bUseTTFFont) {
			guiTTFFont.drawString("save", saveButton.x + 3, saveButton.y + saveButton.height -4);
		}
		else {
			ofDrawBitmapString("save", saveButton.x + 3, saveButton.y + saveButton.height -3);
		}

        ofPopStyle();

        ofPushStyle();
            ofFill();

            if( restoreDown )glColor4fv(fgColor.getSelectedColorF());
            else glColor4fv(fgColor.getColorF());

            ofRect(restoreButton.x, restoreButton.y, restoreButton.width,restoreButton.height);
            ofSetColor(255, 255, 255);
		if(bUseTTFFont) {
			guiTTFFont.drawString("restore", restoreButton.x + 3, restoreButton.y + restoreButton.height -4);
		}
		else {
			ofDrawBitmapString("restore", restoreButton.x + 3, restoreButton.y + restoreButton.height -3);
		}
        ofPopStyle();


        ofPushMatrix();
            ofTranslate(2,0,0);
            glColor4fv(textColor.getColorF());
            guiBaseObject::renderText();
        ofPopMatrix();

        if( !minimize ){

            //don't let gui elements go out of their panels
            glEnable(GL_SCISSOR_TEST);
            glScissor(boundingBox.x, ofGetHeight() - ( boundingBox.y + boundingBox.height - (-2 + topSpacing) ), boundingBox.width - borderWidth , boundingBox.height);

                for(int i = 0; i < (int) panelTabs.size(); i++){
                    if( i == selectedPanel){
                        ofPushStyle();
                            ofFill();
                            glColor4fv(fgColor.getSelectedColorF());
                            ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
                            glColor4fv(outlineColor.getColorF());
                        ofPopStyle();
                    }
                    glColor4fv(outlineColor.getColorF());
                    ofNoFill();
                    ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
                }

                glPushMatrix();
                    glTranslatef(hitArea.x, hitArea.y, 0);
                    for(int i = 0; i < (int) panels.size(); i++){
                        if( i == selectedPanel )panels[i]->render();
                    }
                glPopMatrix();

            glDisable(GL_SCISSOR_TEST);
        }

    ofPopStyle();
}
Example #6
0
//--------------------------------------------------------------
void testApp::draw(){

	if (myPortalCam.needsCalib()) {
	/*	
	 *	So this camera needs to be calibrated only once every time
	 *	either the kinect or screen is physically moved.  Once
	 *	calibrated "needsCalib()" will return as false.  This is
	 *	true for this session, as well as any future sessions (a
	 *	config for the calibration is saved and reloaded whenever
	 *	the app runs).
	 *
	 *	If, for whatever reason, you'd like to manually reset the
	 *	calibration, call the "resetCalib()" function (press the
	 *	"r" key as is defined in the key bindings below).
	 */
		myPortalCam.drawCalib();
	/*	
	 *	"drawCalib()" draws your calibration.  When initialized it will
	 *	show a view from your Kinect's camera.
	 *
	 *	To register your skeleton, do the cactus pose:
	 *		http://bit.ly/cactus_pose
	 *
	 *	Sometimes skeleton registration takes a while... You'll know
	 *	when it happens when a red drawing of your skeleton appears
	 *	superimposed on top of your body.  Once your body registers,
	 *	you're ready to start calibration.
	 *
	 *	Notice that there's a red dot in the top left corner of the
	 *	screen.  Grab your computer mouse and, standing at a distance,
	 *	extend your right arm forward so that your right hand obscures
	 *	your vision of the dot.  When you're there, click the mouse
	 *	button to set that calibration point.
	 *
	 *	A new dot will appear on the right side of the screen.  Do
	 *	the same thing for this dot.  Lastly, it will appear in the
	 *	bottom left corner of the screen.  Do that once again.
	 *
	 *	Great!  You've just calibrated one set of points.  Now we need
	 *	to calibrate 3 other sets of points (4 sets in total).  Stand
	 *	somewhere else in the room and repeat that action for those
	 *	three dots.  The further you can move your head around (while
	 *	keeping your whole head completely the in the Kinect's camera),
	 *	the stronger your calibration will tend to be.
	 *
	 *	When all 12 points (4 sets of 3) are calibrated, you're almost
	 *	done!
	 *
	 *	To finalize the calibration, you will need to "tweak" the
	 *	orientation.  Put your head in line with the center of the
	 *	screen.  It doesn't matter how far away you are from the screen
	 *	as long as your head is in line with the center.  Once there,
	 *	call the "tweakOrientation()" function by pressing "t".
	 *
	 *	Great, you're all calibrated!
	 *
	 */
	} else {
		myPortalCam.begin();
		ofSetColor(255, 255, 255);
		ofBackground(0, 0, 0, 1);
		
		// Draw the wall grids
		int portalDepth = -1000;
		ofNoFill();
		for (int i= 0; i >= portalDepth; i = i - 100) {
			ofPushMatrix();
			ofTranslate(0, 0, i);
			ofRect(-ofGetWindowWidth()/2, -ofGetWindowHeight()/2, ofGetWindowWidth(), ofGetWindowHeight());
			ofPopMatrix();
		}
		for (int i = 0; i < 18; i++) {
			float f = -ofGetWindowWidth()/2 + float(i) * (ofGetWindowWidth() / 18);
			ofPolyline line;
			line.addVertex(f,  ofGetWindowHeight()/2, 0);
			line.addVertex(f,  ofGetWindowHeight()/2, portalDepth);
			line.addVertex(f, -ofGetWindowHeight()/2, portalDepth);
			line.addVertex(f, -ofGetWindowHeight()/2, 0);
			line.draw();
		}
		for (int i = 0; i < 12; i++) {
			float f = -ofGetWindowHeight()/2 + float(i) * (ofGetWindowHeight() / 12);
			ofPolyline line;
			line.addVertex( ofGetWindowWidth()/2, f, 0);
			line.addVertex( ofGetWindowWidth()/2, f, portalDepth);
			line.addVertex(-ofGetWindowWidth()/2, f, portalDepth);
			line.addVertex(-ofGetWindowWidth()/2, f, 0);
			line.draw();
		}
		
		// Draw a sphere
		ofSetColor(0, 255, 0);
		ofSphere(0, 0, portalDepth/2, ofGetWindowHeight() / 4);
		
		myPortalCam.end();
	}
}
//-----------
void ModuleImageAnalyzer::draw() {
    
    
    
    //ofTranslate(320, 240);
    //ofSetHexColor(0xffffff);
//	colorImg = img;
//	colorImg.draw(20,20);
    /*
	int scale = 10;
	hist_img = outHistImg.getCvImage();
	cvZero ( hist_img );
    
	float max_value = 0;
	cvGetMinMaxHistValue( hist, 0, &max_value, 0, 0 );
	for( int h = 0; h < h_bins; h++ ){
		for( int s = 0; s < s_bins; s++ ){
			float bin_val = cvQueryHistValue_2D( hist, h, s );
			int intensity = cvRound( bin_val * 255 / max_value );
            cout << "intensity " << h << " " << s << " " << intensity << " " << bin_val << endl;
			cvRectangle( hist_img, cvPoint( h*scale, s*scale ),
						cvPoint( (h+1)*scale - 1, (s+1)*scale - 1 ),
						CV_RGB( intensity, intensity, intensity ),
						CV_FILLED );
		}
	}
	outImg = hist_img;
	outImg.draw(20, 20);
    */
    
    
    
    
    if (visible) {
        Learn::draw();
        
        ofPushMatrix();
        ofTranslate(x, y);
        //ofScale(0.5, 0.5);

        
        /*
        cam.getTextureReference().bind();
        mesh.draw();
        cam.getTextureReference().unbind();
        if(ofGetMousePressed()) {
            mesh.drawWireframe();
        }
         */

        player.getTextureReference().bind();
        mesh.draw();
        player.getTextureReference().unbind();
        if(ofGetMousePressed()) {
            mesh.drawWireframe();
        }

        diff.draw(640, 0);
        
        
        
        /*
        ofTranslate(0, 400);
        
        
        ofSetColor(255, 0, 0);
        flow.setWindowSize(8);
		flow.calcOpticalFlow(cam);
		int i = 0;
		float distortionStrength = 4;
		for(int y = 1; y + 1 < ySteps; y++) {
			for(int x = 1; x + 1 < xSteps; x++) {
                
                
				int i = y * xSteps + x;
				ofVec2f position(x * stepSize, y * stepSize);
				ofRectangle area(position - ofVec2f(stepSize, stepSize) / 2, stepSize, stepSize);
				ofVec2f offset = flow.getAverageFlowInRegion(area);
                //mesh.setVertex(i, position + distortionStrength * offset);
                ofPushMatrix();
                ofTranslate(x*20, y*20);
                ofLine(0, 0, distortionStrength*offset.x, distortionStrength*offset.y);
                ofPopMatrix();
				i++;
			}
		}
        */
        

        ofTranslate(0, 400);
        drawHistograms();

        
        
        ofPopMatrix();
        

    }
    
    
}
Example #8
0
//-------------------------------
void ofxLabGui::draw(){
    if( hidden ) return;

    ofPushStyle();
    ofEnableAlphaBlending();

        float panelH = boundingBox.height;
        if( minimize ){
            panelH = 20;
        }

		if (bDrawBarOnTop || panels.size() == 0){
			glPushMatrix();
				glTranslatef(boundingBox.x, boundingBox.y, 0);
				//draw the background
				ofFill();
				glColor4fv(bgColor.getColorF());
				ofRect(0, 0, boundingBox.width, panelH);

				//draw the outline
				ofNoFill();
				glColor4fv(outlineColor.getColorF());
				ofRect(0, 0, boundingBox.width, panelH);
				ofLine(0, 20, boundingBox.width, 20);
			glPopMatrix();
		} else {
			glPushMatrix();
				glTranslatef(boundingBox.x, (int) boundingBox.y + panels[0]->getPosY(), 0);
					//draw the background
				ofFill();
				glColor4fv(bgColor.getColorF());
				ofRect(0, 0, boundingBox.width, (int) panelH - panels[0]->getPosY());

				//draw the outline
				ofNoFill();
				glColor4fv(outlineColor.getColorF());
				ofRect(0, 0, boundingBox.width, (int) panelH - panels[0]->getPosY());
				ofLine(0, 20, boundingBox.width, 20);
			glPopMatrix();
		}

		if (bCollapsible) ofRect(minimizeButton.x, minimizeButton.y, minimizeButton.width, minimizeButton.height);
		saveButton->render();
		restoreButton->render();
		loadButton->render();
		saveAsButton->render();
        ofPushMatrix();
            ofTranslate(2,0,0);
            glColor4fv(textColor.getColorF());
            guiBaseObject::renderText();
        ofPopMatrix();

        if( !minimize ){

            //don't let gui elements go out of their panels
            //glEnable(GL_SCISSOR_TEST);
            //glScissor(boundingBox.x, ofGetHeight() - ( boundingBox.y + boundingBox.height - (-2 + topSpacing) ), boundingBox.width - borderWidth , boundingBox.height);
			//glScissor(boundingBox.x-1, ofGetHeight() - ( boundingBox.y + boundingBox.height+1 ), boundingBox.width+2, boundingBox.height+2);
                /*for(int i = 0; i < panelTabs.size(); i++){
                    if( i == selectedPanel){
                        ofPushStyle();
                            ofFill();
                            glColor4fv(fgColor.getSelectedColorF());
							ofBeginShape();
							ofVertex(panelTabs[i].x, panelTabs[i].y+panelTabs[i].height);
							ofVertex(panelTabs[i].x, panelTabs[i].y);
							ofVertex(panelTabs[i].x+panelTabs[i].width, panelTabs[i].y);
							ofVertex(panelTabs[i].x+panelTabs[i].width, panelTabs[i].y + panelTabs[i].height);
							ofEndShape(false);
                            //ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
                            glColor4fv(outlineColor.getColorF());
                        ofPopStyle();
                    }
                    glColor4fv(outlineColor.getColorF());
                    ofNoFill();
					ofBeginShape();
					ofVertex(panelTabs[i].x, panelTabs[i].y+panelTabs[i].height);
					ofVertex(panelTabs[i].x, panelTabs[i].y);
					ofVertex(panelTabs[i].x+panelTabs[i].width, panelTabs[i].y);
					ofVertex(panelTabs[i].x+panelTabs[i].width, panelTabs[i].y + panelTabs[i].height);
					ofEndShape(false);
					//ofRect(panelTabs[i].x, panelTabs[i].y, panelTabs[i].width, panelTabs[i].height);
                }*/

                glPushMatrix();
                    glTranslatef(hitArea.x, hitArea.y, 0);
                    for(int i = 0; i < panels.size(); i++){
                        if( i == selectedPanel )panels[i]->render();
						else panels[i]->renderTab();
                    }
                glPopMatrix();

            //glDisable(GL_SCISSOR_TEST);
        }

    ofPopStyle();
}
Example #9
0
//--------------------------------------------------------------
void ofApp::draw()
{
    //現在のモードに応じて、表示する映像を切り替え
    switch (videoMode)
    {
            
        case 1:
            //グレースケール映像
            grayImage.draw(0, 0, ofGetWidth(), ofGetHeight());
            break;
            
        case 2:
            //背景画像
            grayBg.draw(0, 0, ofGetWidth(), ofGetHeight());
            break;
            
        case 3:
            //2値化された差分映像
            grayDiff.draw(0, 0, ofGetWidth(), ofGetHeight());
            break;
            
        default:
            //カラー映像
            colorImg.draw(0, 0, ofGetWidth(), ofGetHeight());
            break;
    }
    
    //画面に対する映像の比率を計算
    float ratioX = ofGetWidth()/320;
    float ratioY = ofGetHeight()/240;
    
    //解析結果を表示する場合
    if (showCvAnalysis)
    {
        //検出した解析結果を表示
        for (int i = 0; i < contourFinder.nBlobs; i++)
        {
            ofPushMatrix();
            //画面サイズいっぱいに表示されるようリスケール
            glScalef((float)ofGetWidth() / (float)grayDiff.width,
                     (float)ofGetHeight() / (float)grayDiff.height, 1.0f);
            
            contourFinder.blobs[i].draw(0,0);
            ofFill();
            ofSetColor(255, 0, 0);
            ofEllipse(contourFinder.blobs[i].centroid.x, contourFinder.blobs[i].centroid.y, 4, 4);
            ofPopMatrix();
        }
    }
    
    //ログと操作説明を表示
    ofSetColor(255, 255, 255);
    ofDrawBitmapString("FPS: "+ofToString(ofGetFrameRate()), 20, 20);
    ofDrawBitmapString("Threshold: "+ofToString(threshold), 20, 35);
    ofDrawBitmapString("Number of Blobs: "+ofToString(contourFinder.nBlobs), 20, 50);
    ofDrawBitmapString("[0] Show original video", 20, 65);
    ofDrawBitmapString("[1] Show grayscale video", 20, 80);
    ofDrawBitmapString("[2] Show captured background", 20, 95);
    ofDrawBitmapString("[3] Show difference from background", 20, 110);
    ofDrawBitmapString("[space] Captuer background", 20, 125);
    ofDrawBitmapString("[a] Analysis on / off", 20, 140);
    
    ofDrawBitmapString("device0: " + vids[0].deviceName + " " +
                       ofToString(vids[0].id, 2), windowS.x - 320, 65);
    ofDrawBitmapString("device1: " + vids[1].deviceName + " " +
                       ofToString(vids[1].id, 2), windowS.x - 320, 80);
//    ofDrawBitmapString("device2: " + vids[2].deviceName + ofToString(vids[2].id, 1), windowS.x - 20, 95);
//    ofDrawBitmapString("device3: " + vids[3].deviceName + ofToString(vids[3].id, 1), windowS.x - 20, 110);
//    ofDrawBitmapString("device4: " + vids[4].deviceName + ofToString(vids[4].id, 1), windowS.x - 20, 125);

    ofDrawBitmapString("cam: " + ofToString(vids[devID].deviceName,1), windowS.x - 320, 140);
    
}
Example #10
0
//--------------------------------------------------------------
void ofApp::draw() {
    
    float spinX = sin(ofGetElapsedTimef()*.35f);
    float spinY = cos(ofGetElapsedTimef()*.075f);
    
    if(bMousePressed) {
        spinX = spinY = 0.0f;
    }
    
    ofEnableDepthTest();
    
    ofEnableLighting();
    pointLight.enable();
    pointLight2.enable();
    pointLight3.enable();
    
	material.begin();
    
    
    ofSetColor(180);
    ofNoFill();
    ofDrawSphere(ofGetWidth()/2, ofGetHeight()/2, ofGetWidth());
    
    if(mode == 1 || mode == 3) texture.getTexture().bind();
    if(mode == 2) vidGrabber.getTexture().bind();
    
    
    // Plane //
    plane.setPosition(ofGetWidth()*.2, ofGetHeight()*.25, 0);
    plane.rotate(spinX, 1.0, 0.0, 0.0);
    plane.rotate(spinY, 0, 1.0, 0.0);
    
    
    if(mode == 3) {
        deformPlane = plane.getMesh();
        // x = columns, y = rows //
        ofVec3f planeDims = plane.getResolution();
        float planeAngleX = ofGetElapsedTimef()*3.6;
        float planeAngleInc = 3.f/(float)planeDims.x;
        ofVec3f vert;
        for(size_t i = 0; i < deformPlane.getNumIndices(); i++ ) {
            planeAngleX += planeAngleInc;
            int ii = deformPlane.getIndex( i );
            vert = deformPlane.getVertex( ii );
            vert.z += cos(planeAngleX) * 50;
            deformPlane.setVertex( ii, vert );
        }
    }
    
    if(bFill) {
        ofFill();
        ofSetColor(255);
        if(mode == 3) {
            plane.transformGL();
            deformPlane.draw();
            plane.restoreTransformGL();
        } else {
            plane.draw();
        }
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill) ofSetColor(255);
        plane.setPosition(plane.getPosition().x, plane.getPosition().y, plane.getPosition().z+1);
        //if(bFill) {
        if( mode == 3 ) {
            ofSetColor(255);
        }
        plane.drawWireframe();
        //}
        plane.setPosition(plane.getPosition().x, plane.getPosition().y, plane.getPosition().z-2);
        
    }
    
    
    // Box //
    box.setPosition(ofGetWidth()*.5, ofGetHeight()*.25, 0);
    box.rotate(spinX, 1.0, 0.0, 0.0);
    box.rotate(spinY, 0, 1.0, 0.0);
    
    if(bFill) {
        ofFill();
        ofSetColor(255);
        if(mode == 3) {
            box.transformGL();
            for(int i = 0; i < ofBoxPrimitive::SIDES_TOTAL; i++ ) {
                ofPushMatrix();
                ofTranslate( boxSides[i].getNormal(0) * sin(ofGetElapsedTimef()) * 50  );
                boxSides[i].draw();
                ofPopMatrix();
            }
            box.restoreTransformGL();
        } else {
            box.draw();
        }
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill) ofSetColor(255);
        box.setScale(1.01f);
        if(mode == 3) {
            ofSetColor(255);
        }
        box.drawWireframe();
        box.setScale(1.f);
    }
    
    
    // Sphere //
    sphere.setPosition(ofGetWidth()*.8f, ofGetHeight()*.25, 0);
    sphere.rotate(spinX, 1.0, 0.0, 0.0);
    sphere.rotate(spinY, 0, 1.0, 0.0);
    
    if(mode == 3) {
        sphere.setMode( OF_PRIMITIVE_TRIANGLES );
        triangles = sphere.getMesh().getUniqueFaces();
    }
    
    if(bFill) {
        ofFill();
        ofSetColor(255);
        if(mode == 3) {
            float angle = ofGetElapsedTimef()*3.2;
            float strength = (sin( angle+.25 )) * .5f * 5.f;
            ofVec3f faceNormal;
            for(size_t i = 0; i < triangles.size(); i++ ) {
                // store the face normal here.
                // we change the vertices, which makes the face normal change
                // every time that we call getFaceNormal //
                faceNormal = triangles[i].getFaceNormal();
                for(int j = 0; j < 3; j++ ) {
                    triangles[i].setVertex( j, triangles[i].getVertex(j) + faceNormal * strength);
                }
            }
            sphere.getMesh().setFromTriangles( triangles );
        }
        sphere.draw();
        
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill) ofSetColor(255);
        sphere.setScale(1.01f);
        sphere.drawWireframe();
        sphere.setScale(1.f);
    }
    
    
    // ICO Sphere //
    icoSphere.setPosition(ofGetWidth()*.2, ofGetHeight()*.75, 0);
    icoSphere.rotate(spinX, 1.0, 0.0, 0.0);
    icoSphere.rotate(spinY, 0, 1.0, 0.0);
    
    if(mode == 3) {
        triangles = icoSphere.getMesh().getUniqueFaces();
    }
    
    if(bFill) {
        ofFill();
        ofSetColor(255);
        
        if(mode == 3) {
            float angle = (ofGetElapsedTimef() * 1.4);
            ofVec3f faceNormal;
            for(size_t i = 0; i < triangles.size(); i++ ) {
                float frc = ofSignedNoise(angle* (float)i * .1, angle*.05) * 4;
                faceNormal = triangles[i].getFaceNormal();
                for(int j = 0; j < 3; j++ ) {
                    triangles[i].setVertex(j, triangles[i].getVertex(j) + faceNormal * frc );
                }
            }
            icoSphere.getMesh().setFromTriangles( triangles );
        }
        
        icoSphere.draw();
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill) ofSetColor(255);
        icoSphere.setScale(1.01f);
        icoSphere.drawWireframe();
        icoSphere.setScale(1.f);
    }
    
    
    // Cylinder //
    if(mode == 3) {
        topCap      = cylinder.getTopCapMesh();
        bottomCap   = cylinder.getBottomCapMesh();
        body        = cylinder.getCylinderMesh();
    }
    
    cylinder.setPosition(ofGetWidth()*.5, ofGetHeight()*.75, 0);
    cylinder.rotate(spinX, 1.0, 0.0, 0.0);
    cylinder.rotate(spinY, 0, 1.0, 0.0);
    if(bFill) {
        ofFill();
        ofSetColor(255);
        if(mode == 3) {
            cylinder.transformGL();
            ofPushMatrix(); {
                if(topCap.getNumNormals() > 0) {
                    ofTranslate( topCap.getNormal(0) * (cos(ofGetElapsedTimef()*5)+1)*.5f * 100 );
                    topCap.draw();
                }
            } ofPopMatrix();
            ofPushMatrix(); {
                if(bottomCap.getNumNormals() > 0) {
                    ofTranslate( bottomCap.getNormal(0) * (cos(ofGetElapsedTimef()*4)+1)*.5f * 100 );
                    bottomCap.draw();
                }
            } ofPopMatrix();
            ofPushMatrix(); {
                float scale = (cos(ofGetElapsedTimef()*3)+1)*.5f + .2;
                ofScale( scale, scale, scale );
                body.draw();
            } ofPopMatrix();
            cylinder.restoreTransformGL();
        } else {
            cylinder.draw();
        }
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill || mode == 3) ofSetColor(255);
        cylinder.setScale(1.01f);
        cylinder.drawWireframe();
        cylinder.setScale(1.0f);
    }
    
    
    // Cone //
    cone.setPosition(ofGetWidth()*.8, ofGetHeight()*.75, 0);
    cone.rotate(spinX, 1.0, 0.0, 0.0);
    cone.rotate(spinY, 0, 1.0, 0.0);
    
    if(mode == 3) {
        bottomCap   = cone.getCapMesh();
        body        = cone.getConeMesh();
    }
    if(bFill) {
        ofFill();
        ofSetColor(255);
        if(mode == 3) {
            cone.transformGL();
            ofPushMatrix();
            if(bottomCap.getNumNormals() > 0 ) {
                ofTranslate( bottomCap.getNormal(0) * cone.getHeight()*.5 );
                ofRotate( sin(ofGetElapsedTimef()*5) * RAD_TO_DEG, 1, 0, 0);
                bottomCap.draw();
            }
            ofPopMatrix();
            
            ofPushMatrix();
            ofRotate(90, 1, 0, 0);
            ofRotate( (cos(ofGetElapsedTimef()*6) +1)*.5 * 360 , 1, 0, 0 );
            body.draw();
            ofPopMatrix();
            cone.restoreTransformGL();
        } else {
            cone.draw();
        }
    }
    if(bWireframe) {
        ofNoFill();
        ofSetColor(0, 0, 0);
        if(!bFill || mode == 3) ofSetColor(255);
        cone.setScale(1.01f);
        cone.drawWireframe();
        cone.setScale(1.0f);
    }
    
    if(mode == 1 || mode == 3) texture.getTexture().unbind();
    if(mode == 2) vidGrabber.getTexture().unbind();
    
    material.end();
    ofDisableLighting();
    
    if(bDrawLights) {
        ofFill();
        ofSetColor(pointLight.getDiffuseColor());
        pointLight.draw();
        ofSetColor(pointLight2.getDiffuseColor());
        pointLight2.draw();
        ofSetColor(pointLight3.getDiffuseColor());
        pointLight3.draw();
    }
    
    if(bDrawNormals) {
        ofSetColor(225, 0, 255);
        plane.drawNormals(20, bSplitFaces);
        box.drawNormals(20, bSplitFaces);
        sphere.drawNormals(20, bSplitFaces);
        icoSphere.drawNormals(20, bSplitFaces);
        cylinder.drawNormals(20, bSplitFaces);
        cone.drawNormals(20, bSplitFaces);
    }
    if(bDrawAxes) {
        plane.drawAxes(plane.getWidth()*.5+30);
        box.drawAxes(box.getWidth()+30);
        sphere.drawAxes(sphere.getRadius()+30);
        icoSphere.drawAxes(icoSphere.getRadius()+30);
        cylinder.drawAxes(cylinder.getHeight()+30);
        cone.drawAxes(cone.getHeight()+30);
    }
    
    ofDisableDepthTest();
    
    ofFill();
    
    ofSetColor(0);
    ofDrawRectangle(plane.getPosition().x-154, plane.getPosition().y + 120, 140, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofPlanePrimitive", plane.getPosition().x-150, plane.getPosition().y+136 );
    
    ofSetColor(0);
    ofDrawRectangle(box.getPosition().x-154, box.getPosition().y + 120, 126, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofBoxPrimitive", box.getPosition().x-150, box.getPosition().y+136 );
    
    ofSetColor(0);
    ofDrawRectangle(sphere.getPosition().x-154, sphere.getPosition().y + 120, 148, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofSpherePrimitive", sphere.getPosition().x-150, sphere.getPosition().y+136 );
    
    ofSetColor(0);
    ofDrawRectangle(icoSphere.getPosition().x-154, icoSphere.getPosition().y + 120, 168, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofIcoSpherePrimitive", icoSphere.getPosition().x-150, icoSphere.getPosition().y+136 );
    
    ofSetColor(0);
    ofDrawRectangle(cylinder.getPosition().x-154, cylinder.getPosition().y + 120, 160, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofCylinderPrimitive", cylinder.getPosition().x-150, cylinder.getPosition().y+136 );
    
    ofSetColor(0);
    ofDrawRectangle(cone.getPosition().x-154, cone.getPosition().y + 120, 136, 24);
    ofSetColor(255);
    ofDrawBitmapString("ofConePrimitive", cone.getPosition().x-150, cone.getPosition().y+136 );
        
    if(bInfoText) {
        stringstream ss;
        ss << "Framerate: " << ofToString(ofGetFrameRate(),0) << "\n";
        ss << "(f): Toggle Fullscreen"<<endl<<"(s): Draw Solid Shapes"<<endl<<"(w): Draw Wireframes"<<endl;
        ss <<"(1/2/3/4): Set Resolutions" <<endl<<"(n): Draw Normals"<<"\n(LEFT/RIGHT): Set Mode "<<ofToString(mode,0)<<endl;
        ss <<"(z): Split Faces " <<bSplitFaces<<endl;
        ss <<"(a): Draw Axes"<<endl<<"(l): Render lights"<<endl<<"(t): Info Text"<<endl;
        
        ofDrawBitmapString(ss.str().c_str(), 20, 20);
    }
    
    
}
Example #11
0
//--------------------------------------------------------------
void testApp::draw(){
    if(!setupFailed){
        //debug view
        ofPushStyle();
            ofPushMatrix();
                ofTranslate(0, ofGetWindowHeight()-130);
        
                //-----  channel 01 -----
                ofPushMatrix();
                    ofTranslate(100, 0);
                    ofFill();
                    ofDrawBitmapString("Channel01", -90,0);
                    ofSetColor(255,40);
                    ofDrawBitmapString("FFT: "+ ofToString(Channel01_FFT_size) + " freq", 0,15);
                    
                    ofDrawBitmapString("Frequency: " + ofToString(Channel01_Pitch,0), 0,30);
                    ofDrawBitmapString("Linear Pitch: " + ofToString(Channel01_LinearPitch,0), 0,45);
                    ofDrawBitmapString("Amplitude: " + ofToString(Channel01_Amplitude,4), 0,60);
                    ofDrawBitmapString("Attack: " + ofToString(Channel01_Attack,4), 0,75);
                    for (int i = 0; i < Channel01_FFT_size; i++){
                        ofSetColor(255,20);
                        ofRect((i*6),0,5,-Channel01_Analyzer.averages[i] * 3);
                        ofSetColor(255);
                        ofLine((i*6), -Channel01_Analyzer.averages[i] * 3, ((i+1)*6), -Channel01_Analyzer.averages[i+1] * 3);
                    }
                    ofSetColor(255, 255*Channel01_Amplitude);
                    ofCircle(-50,50, Channel01_Attack*3);
                    ofSetColor(255);
                    ofNoFill();
                    ofCircle(-50, 50, Channel01_Attack*3);
                
                ofPopMatrix();
        
                //-----  channel 02 -----
                ofPushMatrix();
                    ofTranslate(350, 0);
                    ofFill();
                    ofDrawBitmapString("Channel02", -90,0);
                    ofSetColor(255,40);
                    ofDrawBitmapString("FFT: "+ ofToString(Channel02_FFT_size) + " freq", 0,15);
                    ofDrawBitmapString("Frequency: " + ofToString(Channel02_Pitch,0), 0,30);
                    ofDrawBitmapString("Linear Pitch: " + ofToString(Channel02_LinearPitch,0), 0,45);
                    ofDrawBitmapString("Amplitude: " + ofToString(Channel02_Amplitude,4), 0,60);
                    ofDrawBitmapString("Attack: " + ofToString(Channel02_Attack,4), 0,75);
                    for (int i = 0; i < Channel02_FFT_size; i++){
                        ofSetColor(255,20);
                        ofRect((i*6),0,5,-Channel02_Analyzer.averages[i] * 3);
                        ofSetColor(255);
                        ofLine((i*6), -Channel02_Analyzer.averages[i] * 3, ((i+1)*6), -Channel02_Analyzer.averages[i+1] * 3);
                    }
                    ofSetColor(255, 255*Channel02_Amplitude);
                    ofCircle(-50,50, Channel02_Attack*3);
                    ofSetColor(255);
                    ofNoFill();
                    ofCircle(-50, 50, Channel02_Attack*3);
                ofPopMatrix();
     
                //-----  channel 03 -----
                ofPushMatrix();
                    ofTranslate(600, 0);
                    ofFill();
                    ofDrawBitmapString("Channel03", -90,0);
                    ofSetColor(255,40);
                    ofDrawBitmapString("FFT: "+ ofToString(Channel03_FFT_size) + " freq", 0,15);
                    ofDrawBitmapString("Frequency: " + ofToString(Channel03_Pitch,0), 0,30);
                    ofDrawBitmapString("Linear Pitch: " + ofToString(Channel03_LinearPitch,0), 0,45);
                    ofDrawBitmapString("Amplitude: " + ofToString(Channel03_Amplitude,4), 0,60);
                    ofDrawBitmapString("Attack: " + ofToString(Channel03_Attack,4), 0,75);
                    for (int i = 0; i < Channel03_FFT_size; i++){
                        ofSetColor(255,20);
                        ofRect((i*6),0,5,-Channel03_Analyzer.averages[i] * 3);
                        ofSetColor(255);
                        ofLine((i*6), -Channel03_Analyzer.averages[i] * 3, ((i+1)*6), -Channel03_Analyzer.averages[i+1] * 3);
                    }
                    ofSetColor(255, 255*Channel03_Amplitude);
                    ofCircle(-50,50, Channel03_Attack*3);
                    ofSetColor(255);
                    ofNoFill();
                    ofCircle(-50, 50, Channel03_Attack*3);
                ofPopMatrix();
                
                
                //-----  channel 04 -----
                ofPushMatrix();
                    ofTranslate(850, 0);
                    ofFill();
                    ofDrawBitmapString("Channel04", -90,0);
                    ofSetColor(255,40);
                    ofDrawBitmapString("FFT: "+ ofToString(Channel04_FFT_size) + " freq", 0,15);
                    ofDrawBitmapString("Frequency: " + ofToString(Channel04_Pitch,0), 0,30);
                    ofDrawBitmapString("Linear Pitch: " + ofToString(Channel04_LinearPitch,0), 0,45);
                    ofDrawBitmapString("Amplitude: " + ofToString(Channel04_Amplitude,4), 0,60);
                    ofDrawBitmapString("Attack: " + ofToString(Channel04_Attack,4), 0,75);
                    for (int i = 0; i < Channel04_FFT_size; i++){
                        ofSetColor(255,20);
                        ofRect((i*6),0,5,-Channel04_Analyzer.averages[i] * 3);
                        ofSetColor(255);
                        ofLine((i*6), -Channel04_Analyzer.averages[i] * 3, ((i+1)*6), -Channel04_Analyzer.averages[i+1] * 3);
                    }
                    ofSetColor(255, 255*Channel04_Amplitude);
                    ofCircle(-50,50, Channel04_Attack*3);
                    ofSetColor(255);
                    ofNoFill();
                    ofCircle(-50, 50, Channel04_Attack*3);
                ofPopMatrix();
        
        
            ofPopMatrix();
        ofPopStyle();
    } else { //setup failed!
    
        ofBackground(255, 20, 0);
        ofSetColor(255);
        ofDrawBitmapString(" WRONG DEVICE SELECTED ", ofGetWidth()/2-90, ofGetHeight()/2 - 50);
        ofDrawBitmapString(" CHANGE SYSTEM SETTINGS ", ofGetWidth()/2-90, ofGetHeight()/2);
        ofDrawBitmapString(" TO 4-CHANNEL INTERFACE ", ofGetWidth()/2-90, ofGetHeight()/2+50);
    }
}
Example #12
0
//--------------------------------------------------------------
void ofApp::draw(){
    ofBackgroundGradient(ofColor(90, 90, 90), ofColor(30, 30, 30),  OF_GRADIENT_BAR);
    
    ofSetColor(200);
    ofDrawBitmapString("ofxLeapMotion - Example App\nLeap Connected? " + ofToString(leap.isConnected()), 20, 20);
    
    cam.begin();
    
    ofPushMatrix();
    ofRotate(90, 0, 0, 1);
    ofSetColor(20);
    ofDrawGridPlane(1000, 50, false); //creates the grid (columns , rows)
    ofPopMatrix();
    
    
    fingerType fingerTypes[] = {THUMB, INDEX, MIDDLE, RING, PINKY};
    
    for(int i = 0; i < simpleHands.size(); i++){
        bool isLeft        = simpleHands[i].isLeft;
        ofPoint handPos    = simpleHands[i].handPos;
        ofPoint handNormal = simpleHands[i].handNormal;
        
        ofSetColor(0, 0, 255);
        ofDrawSphere(handPos.x, handPos.y, handPos.z, 20);
        ofSetColor(255, 255, 0);
        ofDrawArrow(handPos, handPos + 100*handNormal);
        
        for (int f=0; f<5; f++) {
            ofPoint mcp = simpleHands[i].fingers[ fingerTypes[f] ].mcp;  // metacarpal
            ofPoint pip = simpleHands[i].fingers[ fingerTypes[f] ].pip;  // proximal
            ofPoint dip = simpleHands[i].fingers[ fingerTypes[f] ].dip;  // distal
            ofPoint tip = simpleHands[i].fingers[ fingerTypes[f] ].tip;  // fingertip
            
            ofSetColor(0, 255, 0);
            ofDrawSphere(mcp.x, mcp.y, mcp.z, 12);
            ofDrawSphere(pip.x, pip.y, pip.z, 12);
            ofDrawSphere(dip.x, dip.y, dip.z, 12);
            ofDrawSphere(tip.x, tip.y, tip.z, 12);
            
            ofSetColor(255, 0, 0);
            ofSetLineWidth(20);
            ofLine(mcp.x, mcp.y, mcp.z, pip.x, pip.y, pip.z);
            ofLine(pip.x, pip.y, pip.z, dip.x, dip.y, dip.z);
            ofLine(dip.x, dip.y, dip.z, tip.x, tip.y, tip.z);
        }
        
        
        if ((handPos.x > -100) && (handPos.x < 100)) {
            
            synth.play();
        }
        if ((handPos.x > 50) && (handPos.x < 250)) {
            
            beats.play();
        }
        
        
        
        /*if (handPos.y > 100) {
            
            synth.play();
        }*/
        /*if (handPos.z > 100) {
            
            synth.play();
        }*/
        
    }
    cam.end();
    
    
    //sound player
    
    
    /*
    //---------------------------------- synth:
    if (synth.getIsPlaying()) ofSetHexColor(0xFF0000);
    else ofSetHexColor(0x000000);
    font.drawString("synth !!", 50,50);
    
    ofSetHexColor(0x000000);
    string tempStr = "click to play\npct done: "+ofToString(synth.getPosition())+"\nspeed: " + ofToString(synth.getSpeed()) + "\npan: " + ofToString(synth.getPan()) ;
    ofDrawBitmapString(tempStr, 50,ofGetHeight()-50);
    
    
    
    //---------------------------------- beats:
    if (beats.getIsPlaying()) ofSetHexColor(0xFF0000);

    
    ofSetHexColor(0x000000);
    tempStr = "click and drag\npct done: "+ofToString(beats.getPosition())+"\nspeed: " +ofToString(beats.getSpeed());
    
    //---------------------------------- vocals:
    if (vocals.getIsPlaying()) ofSetHexColor(0xFF0000);
    else ofSetHexColor(0x000000);
    
    ofSetHexColor(0x000000);
    tempStr = "click to play (multiplay)\npct done: "+ofToString(vocals.getPosition())+"\nspeed: " + ofToString(vocals.getSpeed());
        */
}
Example #13
0
//--------------------------------------------------------------
void testApp::draw(){
    char reportStr[1024];

	ofPushMatrix();
	ofTranslate(20, 20, 1);
	ofSetLineWidth(1);

	ofSetHexColor(0xffffff);
	colorImg.draw(0, 0);
	colorPin.draw(360, 0);
	grayPin.draw(360, 120);

	grayDiff.draw(0, 280);


	ofNoFill();
	ofSetColor(0, 0, 255, 255);
	ofRect(cntPts.x, cntPts.y + 280, cntPts.width, cntPts.height);

    // Region Numeros
    ofBeginShape();
	for (int i = 0; i < 4; i++) ofVertex(roiPts[i]);
    ofSetColor(moviendo > -1 && moviendo < 4 ? 255 : 0, 255, 0, 255);
    ofEndShape(true);

	ofBeginShape();
	for (int i = 0; i < 4; i++) {
	    ofSetColor(i == moviendo ? 255 : 0, 255, 0, 255);
	    sprintf(reportStr, "%d", i + 1);
	    ofDrawBitmapString(reportStr, roiPts[i].x, roiPts[i].y - 10);
	    ofCircle(roiPts[i].x, roiPts[i].y, 5);
        ofVertex(roiPts[i]);
	}
	ofFill();
    ofSetColor(0, 255, 0, 32);
	ofEndShape();

    // Region barritas contador
	ofNoFill();
    ofSetColor(255, moviendo > -1 ? 255 : 0, 0, 255);
    ofRect(cntPts);
    ofDrawBitmapString("x, y", cntPts.x, cntPts.y - 10);
    ofDrawBitmapString("w, h", cntPts.x + cntPts.width, cntPts.y + cntPts.height + 10);
    ofCircle(cntPts.x, cntPts.y, 5);
    ofCircle(cntPts.x + cntPts.width, cntPts.y + cntPts.height, 5);

	ofSetHexColor(0x333333);
	ofRect(360,540,320,240);


    ofFill();
	ofSetColor(0, 0, 0, 196);
	ofRect(0, 180, 320, 50);

	ofSetHexColor(0xffffff);
	sprintf(reportStr, "[+/-] - Cambiar threshold: %i\n[ G ] - Guardar configuracion\nUltima barra presente: %s\nToken detectado: %s", threshold, ultimaBarra ? "SI" : "NO", token);
	ofDrawBitmapString(reportStr, 5, 195);


    // detecta los numeros de 7 segmentos
    ofNoFill();
    ofSetColor(0, 0, 255, 255);
    ofSetLineWidth(2);
    for (int x = 0; x < 45 * 6; x += 50) {
        ofRect(360 + (x > 110 ? x + 25 : x), 120, 45, 120);
    }

    bool segmento[6], cambio = false;
    int lpixel = 0, pixel = 255, cambios = 0;

    for (int y = 30; y < 61; y += 60)
    for (int x = 0; x < 45; x++) {
        int i = x+ (y * 320);
        lpixel = pixel;
        pixel = grayPin.getPixels()[i];
        cambio = (lpixel != pixel);// && lpixel;
        if (cambio) cambios++;
    }

    printf ("cambios: %d\n", cambios);




	ofPopMatrix();

}
Example #14
0
//--------------------------------------------------------------
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){
        ofBackground(100);
        targetPos = 0.98 * targetPos + 0.02 *selectionPoint;
    } else {
        ofBackground(150);
        targetPos = 0.98 * targetPos + 0.02 *centerPos;
    }
    
    ofPushMatrix();
    ofTranslate(-targetPos.x,-targetPos.y);
    ofTranslate(centerPos.x,centerPos.y);
    
    for (int i=0; i<frames.size();i++){
        if (!frames[i].isSelected()) {
            frames[i].draw();
        }
    }
    
    
    for (int i=0; i<frames.size();i++){
        if (frames[i].isSelected()) {
            frames[i].draw();
        }
    }
    
    ofPopMatrix();
    
  

    if (enable_Debug_Mode) {
        string info =  "INFO : \n";
        info += "space: add new frame\n";
        info += "key = 'w': width + \n";
        info += "key = 's': width - \n";
        info += "key = 'a': rotate left \n";
        info += "key = 'd': rotate right \n";
        info += "key = 'z': delete last frame \n";
        info += "number key = 1, 2, 3, 4 : level 1 - 4 \n";
        info += "key = 'e' : frame style 1 - 4 \n";
        info += "key = 'q' : shadow style 1 - 4 \n";
        info += "Level = "+ ofToString(frames.back().getLevel())+"\n";

        ofSetColor(255);
        ofDrawBitmapStringHighlight(info, 20,20);
    }else{
        ofSetColor(255);
        banner.draw(0, 0, banner.width/2,banner.height/2);
    }
    
}
Example #15
0
	//----------
	void Device::drawWorld() {
		auto colorSource = this->getColorSource();
		auto depthSource = this->getDepthSource();
		auto bodySource = this->getBodySource();

		if (!depthSource) {
			ofLogError("ofxKinectForWindows2::Device::drawPrettyMesh") << "No depth source initialised";
			return;
		}
		
		//point cloud
		{
			//setup some point cloud properties for kicks
			bool usePointSize = true;

#if OF_VERSION_MAJOR > 0 || OF_VERSION_MINOR >= 10
			auto mainWindow = std::static_pointer_cast<ofAppGLFWWindow>(ofGetCurrentWindow());
			usePointSize = mainWindow ? mainWindow->getSettings().glVersionMajor <= 2 : false;
#endif

			usePointSize = false;

			if (usePointSize) {
				glPushAttrib(GL_POINT_BIT);
				glPointSize(5.0f);
				glEnable(GL_POINT_SMOOTH);
			}

			ofPushStyle();

			bool useColor = colorSource.get();
			if (useColor) {
				useColor &= colorSource->getTexture().isAllocated();
			}

			if (useColor) {
				//bind kinect color camera texture and draw mesh from depth (which has texture coordinates)
				colorSource->getTexture().bind();
			}

			auto opts = Source::Depth::PointCloudOptions(true, Source::Depth::PointCloudOptions::TextureCoordinates::ColorCamera);
			auto mesh = depthSource->getMesh(opts);

			//draw point cloud
			mesh.drawVertices();

			//draw triangles
			ofSetColor(255, 150);
			mesh.drawWireframe();

			//draw fills faded
			ofSetColor(255, 50);
			mesh.drawFaces();

			if (useColor) {
				//unbind colour camera
				colorSource->getTexture().unbind();
			}

			ofPopStyle();

			//clear the point cloud drawing attributes
			if (usePointSize) {
				glPopAttrib();
			}
		}
		
		//bodies and floor
		if (bodySource) {
			bodySource->drawWorld();

			ofPushMatrix();
			ofRotateDeg(90, 0, 0, 1);
			ofMultMatrix(bodySource->getFloorTransform());
			ofDrawGridPlane(5.0f);
			ofPopMatrix();
		}

		//draw the view cones of depth and colour cameras
		ofPushStyle();
		ofNoFill();
		ofSetLineWidth(2.0f);
		ofSetColor(100, 200, 100);
		depthSource->drawFrustum();
		if (colorSource) {
			ofSetColor(200, 100, 100);
			colorSource->drawFrustum();
		}
		ofPopStyle();
	}
Example #16
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 #17
0
void TextBlock::draw(){
    float yAlig = y;
    
    if (vAlignment == OF_TEXT_ALIGN_BOTTOM){
        yAlig = y + height - getTextHeight();
    } else if (vAlignment == OF_TEXT_ALIGN_MIDDLE){
        yAlig = getCenter().y - getTextHeight()*0.5;
    }
    
    if (hAlignment == OF_TEXT_ALIGN_LEFT){
        string  strToDraw;
        int     currentWordID;
        float   drawX;
        float   drawY;
        
        float currX = 0;
        
        if (words.size() > 0){
            for(int l=0;l < lines.size(); l++){
                for(int w=0;w < lines[l].wordsID.size(); w++){
                    
                    currentWordID = lines[l].wordsID[w];
                    
                    drawX = x + currX;
                    drawY = yAlig + (font->getLineHeight() * (l + 1));
                    
                    ofPushMatrix();
                    font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY);
                    currX += words[currentWordID].width;
                    ofPopMatrix();
                    
                }
                currX = 0;
            }
        }
    } else if (hAlignment == OF_TEXT_ALIGN_RIGHT){
        string  strToDraw;
        int     currentWordID;
        float   drawX;
        float   drawY;
        
        float currX = 0;
        
        if (words.size() > 0) {
            
            for(int l=0;l < lines.size(); l++){
                for(int w=lines[l].wordsID.size() - 1; w >= 0; w--){
                    
                    currentWordID = lines[l].wordsID[w];
                    
                    drawX = -currX - words[currentWordID].width;
                    drawY = font->getLineHeight() * (l + 1);
                    
                    ofPushMatrix();
                    
                    //Move to top left point using pre-scaled co-ordinates
                    ofTranslate(x + width, yAlig, 0.0f);
                    
                    font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY);
                    currX += words[currentWordID].width;
                    
                    ofPopMatrix();
                    
                }
                currX = 0;
                
            }
        }
    } else if (hAlignment == OF_TEXT_ALIGN_JUSTIFIED){
        string  strToDraw;
        int     currentWordID;
        float   drawX;
        float   drawY;
        int     spacesN;
        float   nonSpaceWordWidth;
        float   pixelsPerSpace;
        
        float currX = 0;
        
        if (words.size() > 0) {
            for(int l=0;l < lines.size(); l++){
                //Find number of spaces and width of other words;
                spacesN = 0;
                nonSpaceWordWidth = 0;
                
                for(int w = 0; w < lines[l].wordsID.size(); w++){
                    currentWordID = lines[l].wordsID[w];
                    if (words[currentWordID].rawWord == " ") spacesN++;
                    else nonSpaceWordWidth += words[currentWordID].width;
                }
                
                pixelsPerSpace = (width - x - nonSpaceWordWidth) / spacesN;
                
                for(int w=0;w < lines[l].wordsID.size(); w++){
                    currentWordID = lines[l].wordsID[w];
                    
                    drawX = currX;
                    drawY = font->getLineHeight() * (l + 1);
                    
                    ofPushMatrix();
                    //Move to top left point using pre-scaled co-ordinates
                    ofTranslate(x, yAlig, 0.0f);
                    
                    if (words[currentWordID].rawWord != " ") {
                        font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY);
                        currX += words[currentWordID].width;
                    } else {
                        currX += pixelsPerSpace;
                    }
                    ofPopMatrix();
                    
                }
                currX = 0;
                
            }
        }
    } else if (hAlignment == OF_TEXT_ALIGN_CENTER ){
        string  strToDraw;
        int     currentWordID;
        float   drawX;
        float   drawY;
        float   lineWidth;
        
        float currX = 0;
        
        if (words.size() > 0) {
            for(int l=0;l < lines.size(); l++){
                
                //Get the length of the line.
                lineWidth = 0;
                for(int w=0;w < lines[l].wordsID.size(); w++){
                    currentWordID = lines[l].wordsID[w];
                    lineWidth += words[currentWordID].width;
                }
                
                for(int w=0;w < lines[l].wordsID.size(); w++){
                    currentWordID = lines[l].wordsID[w];
                    
                    drawX = -(lineWidth / 2) + currX;
                    drawY = font->getLineHeight() * (l + 1);
                    
                    ofPushMatrix();
                    //Move to central point using pre-scaled co-ordinates
                    ofTranslate(getCenter().x, yAlig, 0.0f);
                    font->drawString(words[currentWordID].rawWord.c_str(), drawX, drawY);
                    currX += words[currentWordID].width;
                    ofPopMatrix();
                    
                }
                currX = 0;
            }
        }
    }
}
//--------------------------------------------------------------
void ofApp::draw(){
    // DISPLAY STATUS
    ofDrawBitmapString("Recording Status: " + status, 0, 20);
    ofDrawBitmapString("Recognition Status: " + statusWord, 0, 40);
    
    // AUDIO INPUT
    
    ofNoFill();
    
    // draw the average volume:
    ofPushStyle();
    ofPushMatrix();
    ofTranslate(300, 150, 0);
    
    ofSetColor(225);
    ofDrawBitmapString("Scaled average vol: " + ofToString(scaledVol * 100.0, 0), 4, 18);
    ofRect(0, 0, 400, 400);
    
    ofSetColor(245, 58, 135);
    ofFill();
    //ofCircle(200, 200, scaledVol * 180.0f);
    
    //lets draw the volume history as a graph
    if (isRecording) {
        ofBeginShape();
        for (unsigned int i = 0; i < volHistory.size(); i++){
            if( i == 0 ) ofVertex(i, 400);
            
            ofVertex(i, 400 - volHistory[i] * 70);
            
            if( i == volHistory.size() -1 ) ofVertex(i, 400);
        }
        ofEndShape(false);
    }
    
    ofPopMatrix();
    ofPopStyle();
    
    // DRAW FONT
    if (!isRecording && volHistory.size() != 0
        && hasRecognized) {
        //cout << "Mesh Size: " << meshesFront.size() << endl;
        
        // WAVE
        if(ofGetElapsedTimef() > addCountAt){
            tempHistory = (tempHistory + 1)%volHistory.size();
            
            addCountAt = ofGetElapsedTimef() + volHistory.size() * 0.001;
        }
        
        for (unsigned int i = 0; i < meshesFront.size(); i++) {
            float scale = meshesFront.size()/400.0;
            
            // DRAW MESH
            ofPushStyle();
            ofPushMatrix();
            
            ofTranslate(300, 350, 0);
            ofScale(1, volHistory[countHistory] * 2.0);
            
            meshesFront[i].draw();
            
            ofPopMatrix();
            ofPopStyle();
            countHistory = (countHistory + 1)%volHistory.size();
        }
        countHistory = tempHistory;
    }
    
}
Example #19
0
/**
 * Function: draw
 * --------------
 * Use the waveform and FFT buffers
 * to render a tunnel-like thing.
 */
void ofApp::draw() {
    // TBD: figure out good title
    ofSetWindowTitle(country.name);

    float time = ofGetElapsedTimef(); // get time in seconds
    float angle = time * rotMultiplier; // rotation angle [and speed]

    /* float widthAngle = angle / 180 * PI;
    float heightAngle = (angle - 90) / 180 / PI;
    float scaledWidth, scaledHeight;

    float absCosWidthAngle = fabs(cos(widthAngle));
    float absSinWidthAngle = fabs(sin(widthAngle));
    float absCosHeightAngle = fabs(cos(heightAngle));
    float absSinHeightAngle = fabs(sin(heightAngle));

    if (ofGetWidth() / 2 * absSinWidthAngle <= ofGetHeight() / 2 * absCosWidthAngle)
      scaledWidth = ofGetWidth() / 2 / absCosWidthAngle;
    else scaledWidth = ofGetHeight() / 2 / absSinWidthAngle;

    if (ofGetWidth() / 2 * absSinHeightAngle <= ofGetHeight() / 2 * absCosHeightAngle)
      scaledHeight = ofGetWidth() / 2 / absCosHeightAngle;
    else scaledHeight = ofGetHeight() / 2 / absSinHeightAngle; */

    // just some experimentation for a seamless tunnel
    float scaledHeight = max(ofGetHeight(), ofGetWidth());
    float scaledWidth = max(ofGetHeight(), ofGetWidth());

    // just for correctness
    bufferLock.lock();

    // calculate the waveform drawing
    for (int i = 0; i < bufferSize; i += 2) {
        float offset = (scaledWidth / 2) / (bufferSize / 2) * bufferSize / 12;
        float x = (scaledWidth / 2) / (bufferSize / 2) * i; // fit hallway
        float y = inBuffer[i] * (scaledHeight / 2) / (bufferSize / 2) * i;
        wave.addVertex(ofPoint(x + offset, y, 0));

        float alpha = ((float) 255 / (float) bufferSize) * 2 * i;
        ofColor waveColor = country.colorOne;
        waveColor.a = (int) alpha;
        wave.addColor(waveColor);
    }

    // so threadsafe
    bufferLock.unlock();

    float ellipseWidth = ofGetWidth() / 2 * sqrt(2);
    float ellipseHeight = ofGetHeight() / 2 * sqrt(2);
    if (fftBuffers.size() <= 10) return; // get some data first

    if (beat.isHat() || beat.isSnare())
        beatCount += 1; // for cycling

    if (beatCount % 64 == 0 && cyclingMode) // cycle flag
        country = flags[(++flagIndex) % flagCount];

    // calculate the FFT spectrum drawing
    for (int i = 0; i < fftBuffers.size() - 10; i += 1) {
        vector<float> fftBuffer = fftBuffers[i];
        int rev = fftBuffers.size() - 1 - i; // see above

        // so that we avoid overlap on the innermost rings
        int step = (rev > 10) ? 2 : ((rev > 5) ? 4 : 8);

        // for each FFT frequency in the buffer [by step]
        for (int j = 0; j < bufferSize; j += step) {
            float magnitude = sqrt(pow(fftBuffer[j], 2) + pow(fftBuffer[j + 1], 2)); // complex norm
            float theta = 2 * PI / (bufferSize / step) * j / step; // parametrize frequency by angle

            // used for ellipse parametrization in ellipse mode
            float maxRadius = sqrt(pow(ellipseWidth * cos(theta), 2) + pow(ellipseHeight * sin(theta), 2));
            float bufferRadius = maxRadius / fftBuffers.size() * rev; // get radius by buffer num and angle

            float maxWidth = scaledWidth / 2;
            float maxHeight = scaledHeight / 2;
            float bufferWidth = maxWidth / (fftBuffers.size() - 15) * rev;
            float bufferHeight = maxHeight / (fftBuffers.size() - 15) * rev;

            // two ways
            float x, y;

            if (ellipseMode) x = (1 + magnitude) * bufferRadius * cos(theta); // for rectangles we use Lame curves
            else x = (1 + magnitude) * bufferWidth * (abs(cos(theta)) * cos(theta) + abs(sin(theta)) * sin(theta));

            if (ellipseMode) y = (1 + magnitude) * bufferRadius * sin(theta); // for rectangles we use Lame curves
            else y = (1 + magnitude) * bufferHeight * (abs(cos(theta)) * cos(theta) - abs(sin(theta)) * sin(theta));

            spectrum.addVertex(ofPoint(x, y, 0)); // TBD: depth?
            float alpha = ((float) 20 / (float) fftBuffers.size()) * rev + 235;

            scaledVol = ofMap(smoothedVol, 0.0, 0.17, 0.0, 1.0, true);
            // if (beat.isKick()) spectrum.addColor(country.colorOne);
            if (beat.isHat()) spectrum.addColor(ofColor(country.colorTwo));
            if (beat.isSnare()) spectrum.addColor(ofColor(country.colorThree));
            spectrum.addColor(country.gradientFn(i, fftBuffers.size(), alpha));
        }
    }

    ofEnableDepthTest(); // enable z-buffering
    ofBackgroundGradient(ofColor(0, 0, 0), ofColor(0, 0, 0));

    ofPushMatrix(); // draw the spectrum first
    ofEnableAlphaBlending(); // for transparency
    ofTranslate(ofGetWidth() / 2, ofGetHeight() / 2, 0);
    ofRotate(angle); // see controls

    if (drawingType == 1) {
        spectrum.setMode(OF_PRIMITIVE_LINE_STRIP);
        ofSetLineWidth(2);
    }

    else if (drawingType == 2) {
        spectrum.setMode(OF_PRIMITIVE_POINTS);
        glPointSize(3);
        glEnable( GL_POINT_SMOOTH );
    }

    // drawingType == 3 corresponds to triangles
    else spectrum.setMode(OF_PRIMITIVE_TRIANGLES);

    spectrum.draw(); // draw the spectrum mesh
    ofDisableAlphaBlending(); // turn off transparency
    spectrum.clear(); // clear the mesh for next time
    ofPopMatrix(); // restore the coordinate system

    ofPushMatrix(); // then draw the waveform
    ofEnableAlphaBlending(); // for transparency
    // ofSetColor(ofColor(255, 255, 255));

    wave.setMode(OF_PRIMITIVE_LINE_STRIP);
    ofSetLineWidth(5);

    ofTranslate(ofGetWidth() / 2, ofGetHeight() / 2, 0);
    ofRotate(angle); // sync with spectrum rotation
    wave.draw(); // draw the mesh
    ofRotate(180); // reflect mesh
    wave.draw(); // draw mesh again
    ofDisableAlphaBlending();

    wave.clear(); // clear the mesh for next time
    ofPopMatrix(); // restore the coordinate system
}
Example #20
0
void scene01::draw(){
    
    bool bAnySelected = false;
    ofPoint selectionPoint;

    for (int i=0; i<photos.size();i++){
        if (photos[i].condition == photo::seleced) {
            bAnySelected = true;
            selectionPoint =photos[i].pos;
            dragPoint = photos[i].pos;
        }
    }
    
    if (bAnySelected){
        targetPos = 0.92 * targetPos + 0.08 *selectionPoint;
    }else{
        targetPos = 0.70 * targetPos + 0.30 *dragPoint;
    }
    
    //------------------------------------------------darg

    ofPushMatrix();
    
    ofTranslate(-targetPos.x,-targetPos.y,screenZ);
    ofTranslate(centerPos.x,centerPos.y, 0);
    
    for (int i=0; i<photos.size(); i++) {
        if (photos[i].condition == photo::display) {
            photos[i].draw();
        }
    }
    
    for (int i=0; i<photos.size(); i++) {
        if (photos[i].condition == photo::seleced) {
            photos[i].draw();
        }
    }
    
    ofPopMatrix();
    
    //------------------------------------------------buttons
    for (int i=0; i<photos.size(); i++) {
        if (photos[i].animation == photo::stop) {
            ofSetColor(255);
            createOwn.draw(createOwnRect);
            moreMoto.draw(moreMotoRect);
            closeIcon.draw(closeIconRect);
            break;
        }
    }
    
    if (bNarrow) {
        ofSetColor(255);
        ofPushMatrix();
        ofTranslate(ofGetWidth()/2, ofGetHeight()/2);
        int w = narrow.getWidth()/6;
        int h = narrow.getHeight()/6;
        narrow.draw(-w/2,-h/2, w,h);
        ofPopMatrix();
    }
    
}
Example #21
0
//--------------------------------------------------------------
void testApp::draw() {

	ofEnableAlphaBlending();
	ofSetHexColor(0xffffff);


	// we read the values in the depth buffer and test against them.
	// We are also *writing* to the depth buffer when we draw
	glEnable(GL_DEPTH_TEST);

	ofPushMatrix();
	ofTranslate(ofGetWidth()/2, ofGetHeight()/2, zoom);
	ofRotate(cameraRotation.x, 1, 0, 0);
	ofRotate(cameraRotation.y, 0, 1, 0);
	ofRotate(cameraRotation.y, 0, 0, 1);

	// Now we *Still test against depth*,
	// but we *no longer write* to the depth buffer
	glDepthMask(GL_FALSE);

	// bind the shader so that wee can change the
	// size of the points via the vert shader
	billboardShader.begin();
	billboardShader.setUniform1fv("pointSize", billboardSize, NUM_BILLBOARDS);

	ofEnableAlphaBlending();
	ofEnablePointSprites();
	texture.getTextureReference().bind();
	billboardVbo.bind();
	billboardVbo.setVertexData(billboardVerts, NUM_BILLBOARDS, GL_DYNAMIC_DRAW);
	billboardVbo.setColorData(billboardColor, NUM_BILLBOARDS, GL_DYNAMIC_DRAW);
	billboardVbo.draw(GL_POINTS, 0, NUM_BILLBOARDS);

	billboardVbo.unbind();
	texture.getTextureReference().unbind();
	ofDisablePointSprites();

	billboardShader.end();

	ofPopMatrix();



	// re0enable writing to the depth buffer, so the next drame is ok.
	// We need to do this because GL is a state machine, and its a dumb mother fucker.
	glDepthMask(GL_TRUE);


	ofPushStyle();
	ofEnableAlphaBlending();
	ofSetHexColor(0xffffff);
	texture.draw(30, 80);

	//ofSetHexColor(0xff0000);
	//ofNoFill();
	//ofRect(20, 100, texture.getWidth(), texture.getHeight());
	ofSetHexColor(0xffffff);
	ofDrawBitmapString("<-- This is your billboard texture\n    the texture needs to a power of\n    2 for proper rendering.", 95, 32+texture.getHeight());

	// -------------------------
	// debug info
	ofSetColor(255, 255, 255);
	string info = ofToString(ofGetFrameRate(), 2)+"\n";
	info += "Particle Count: "+ofToString(NUM_BILLBOARDS)+"\n";
	ofDrawBitmapString(info, 30, 30);
	ofPopStyle();
}
Example #22
0
void slitScanApp::draw(){
	
	if(!useLiveVideo){
		//weird video player bug... may not need this any more
		vidPlayer.play();
	}
	
	ofPushStyle();{
		ofSetHexColor(COLOR_GREEN_DARK);
		ofRect(0, 0, ofGetWidth(), ofGetHeight());
	}ofPopStyle();
	
	if(isFullScreen){
		warp.getOutputImage().draw(0, 0, ofGetWidth(), ofGetHeight());
		return;
	}
	
	//Draw top selector
	ofPushStyle(); ofPushMatrix(); {
		
		ofFill();
		ofSetHexColor(COLOR_GREEN_DARK);
		ofRect(0, 0, DRAW_WIDTH, SELECTOR_HEIGHT);
		
		ofSetHexColor(0xffffff);
		for(int i = 0; i <= sampleMaps.size(); i++){
			//if it's selected, draw a selection highlight
			if(i == currentSampleMapIndex){
				ofPushStyle();{
					ofSetHexColor(COLOR_GREEN_LIGHT);
					ofRect(FRAME_PADDING/2 + i*(MAP_THUMB_WIDTH+FRAME_PADDING), 
						   FRAME_PADDING/2, 
						   MAP_THUMB_WIDTH+FRAME_PADDING, 
						   MAP_THUMB_HEIGHT+FRAME_PADDING);
					
					ofNoFill();
					ofSetHexColor(COLOR_YELLOW_HIGHLIGHT);
					ofRect(FRAME_PADDING/2 + i*(MAP_THUMB_WIDTH+FRAME_PADDING), 
						   FRAME_PADDING/2, 
						   MAP_THUMB_WIDTH+FRAME_PADDING, 
						   MAP_THUMB_HEIGHT+FRAME_PADDING);
					
				} ofPopStyle();
			}
			
			if(i < sampleMaps.size()){
				//draw the map
				sampleMaps[i]->draw(FRAME_PADDING + i*(MAP_THUMB_WIDTH+FRAME_PADDING), 
								FRAME_PADDING, 
								MAP_THUMB_WIDTH, 
								MAP_THUMB_HEIGHT );
			}
			else{
				if(currentSampleMapIndex == i){
					customMap.draw(FRAME_PADDING + i*(MAP_THUMB_WIDTH+FRAME_PADDING), 
								   FRAME_PADDING, 
								   MAP_THUMB_WIDTH, 
								   MAP_THUMB_HEIGHT);
				}
				else{
					ofSetHexColor(0xFFFFFF);
					loadYourOwn.draw(FRAME_PADDING + i*(MAP_THUMB_WIDTH+FRAME_PADDING), FRAME_PADDING);				
				}
			}
		}
		
	} ofPopMatrix(); ofPopStyle();	
	
	
	ofTranslate(0, SELECTOR_HEIGHT);

	//Draw view ports
	ofPushStyle(); ofPushMatrix(); {
		
		ofFill();
		ofSetHexColor(COLOR_YELLOW);
		ofRect(0, 0, WIDTH+(FRAME_PADDING*2), HEIGHT+(FRAME_PADDING*2));
		
		ofSetHexColor(0xffffff);
		warp.getOutputImage().draw(FRAME_PADDING, FRAME_PADDING);
		
		//if we are hovering, draw the overlay
		//normalize coordinates for (0,0) at top of the overlay
		int viewMouseX = mouseX - FRAME_PADDING*2;
		int viewMouseY = mouseY - (FRAME_PADDING*2 + SELECTOR_HEIGHT); 
		if(viewMouseX > 0 && viewMouseX < WIDTH && viewMouseY > 0 && viewMouseY < HEIGHT){

			ofEnableAlphaBlending();
						
			//movie / live video selector
			ofPushMatrix(); ofPushStyle();{
				ofTranslate(FRAME_PADDING*2, FRAME_PADDING*2);
				
				if(useLiveVideo){
					buttonLiveOn.draw(0,0);
				}
				else {
					buttonMovieOn.draw(0, 0);
				}

			} ofPopMatrix(); ofPopStyle();

			//frame blender
			ofPushMatrix(); ofPushStyle(); {
				ofTranslate(WIDTH -  HUD_BUTTON_WIDTH, FRAME_PADDING*2);
				
				if(warp.isBlending()){
					buttonBlendingOn.draw(0,0);
				}
				else{
					buttonBlendingOff.draw(0, 0);				
				}
				
			} ofPopMatrix(); ofPopStyle();
			
			
			//pause button
			ofPushMatrix(); ofPushStyle();{
				
				ofTranslate(FRAME_PADDING*2, HEIGHT - ( FRAME_PADDING+HUD_BUTTON_HEIGHT));
								
				if(isPaused){
					buttonPauseOn.draw(0, 0);
				}
				else{
					buttonPauseOff.draw(0, 0);
				}
				
			} ofPopMatrix(); ofPopStyle();
			
			//full screen button
			ofPushMatrix(); ofPushStyle();{
				
				ofTranslate(WIDTH - HUD_BUTTON_WIDTH, HEIGHT - ( FRAME_PADDING+HUD_BUTTON_HEIGHT));
				
				buttonFullscreenOff.draw(0,0);
				
			} ofPopMatrix(); ofPopStyle();
		}
		
		ofTranslate(WIDTH+(FRAME_PADDING*2), 0);
		ofSetHexColor(COLOR_GREEN_DARK);
		ofRect(0, 0, WIDTH+(FRAME_PADDING*2), HEIGHT+(FRAME_PADDING*2));		
		
		ofSetHexColor(0xffffff);
		warp.getDelayMap().draw(FRAME_PADDING, FRAME_PADDING, WIDTH, HEIGHT);
		
	} ofPopMatrix(); ofPopStyle();	
	
	ofTranslate(0, HEIGHT+FRAME_PADDING*2);

	//draw filmstrip
	ofPushStyle(); ofPushMatrix(); {
		
		ofFill();
		ofSetHexColor(COLOR_YELLOW);		
		ofRect(0, 0, DRAW_WIDTH, heightPerFrame+FRAME_PADDING*4);
		
		ofTranslate(FRAME_PADDING+CLAMP_HANDLE_WIDTH, FRAME_PADDING);
		
		ofSetHexColor(0xffffff);		
		int frameStep = warp.getCapacity() / framesToShow;
		int fameIndex = 0;
		unsigned char* pixels = previewImage.getPixels();
		for(int i = 0; i < framesToShow; i ++){
			warp.pixelsForFrame(warp.getCapacity() - (frameStep*i) - 1, pixels);
			previewImage.setFromPixels(pixels, WIDTH, HEIGHT, OF_IMAGE_COLOR);
			previewImage.draw(widthPerFrame*i, FRAME_PADDING, widthPerFrame, heightPerFrame);
		}
		
		float leftClampX = leftClamp * filmStripWidth;
		float rightClampX = rightClamp * filmStripWidth;

		ofEnableAlphaBlending();
		ofSetColor(0xac, 0x99, 0x66, 200);
		ofFill();
		
		//block out left side
		ofRect(0, 0, leftClampX, FRAME_PADDING+heightPerFrame);
		
		//block out right side
		ofRect(rightClampX, 0, filmStripWidth - rightClampX, heightPerFrame+FRAME_PADDING);
		
		//handles 
		ofSetHexColor(0xFFFFFF);
		leftHandle.draw(leftClampX - 1, 0);
		rightHandle.draw(rightClampX - CLAMP_HANDLE_WIDTH, FRAME_PADDING);
		
		ofDisableAlphaBlending();
		
	} ofPopMatrix(); ofPopStyle();	
	
	
	//draw capacity slider
	ofTranslate(0, heightPerFrame + FRAME_PADDING*3);

	ofPushStyle(); ofPushMatrix(); {
		
		ofFill();
		ofSetHexColor(COLOR_YELLOW);		
		ofRect(0, 0, DRAW_WIDTH, CAPACITY_SLIDER_HEIGHT + FRAME_PADDING*2);
		
		ofTranslate(FRAME_PADDING, FRAME_PADDING);
		
		float capacitySliderWidth = DRAW_WIDTH - FRAME_PADDING*2;
		
		ofSetHexColor(0xFFFFFF);
		frameCapacityBar.draw(0,0);
		
		ofFill();
		ofSetHexColor(COLOR_YELLOW);		
		ofRect(capacitySliderWidth * (1.0 * capacity / MAX_CAPACITY), 1, 
			   capacitySliderWidth * (1.0 - 1.0 * capacity / MAX_CAPACITY)-1 , CAPACITY_SLIDER_HEIGHT-2);
		
		ofSetHexColor(0xFFFFFF);
		ofEnableAlphaBlending();
		frameCapacityText.draw(capacitySliderWidth/2 - frameCapacityText.width/2, CAPACITY_SLIDER_HEIGHT/2.0 - frameCapacityText.height/2);
		ofDisableAlphaBlending();
		
	} ofPopMatrix(); ofPopStyle();

	//draw bottom label
	ofTranslate(0, CAPACITY_SLIDER_HEIGHT + 22);
	bottomImage.draw(0,0);	
}
Example #23
0
//--------------------------------------------------------------
void ofApp::draw()
{
	ofBackground(30);
    
    float w = _shapeSize;
    float s = 40.0f;
    float x = s;
    float y = s;
    
    ofSetColor(ofColor::fromHex(0xFF7B87));
    ofRect(x, y, 0, w, w);
    
    x += w + s;
    ofSetColor(ofColor::fromHex(0x475887));
    ofCircle(x + w/2, y + w/2, w/2);
    
    x += w + s;
    ofSetColor(220, 222, 121);
    ofSetLineWidth(30.0f);
    ofLine(x + s, y + s, x + w - s, y + w - s);
    
    x += w + s;
    ofSetColor(255, 232, 183);
    ofEllipse(x + w, y + w/2, w*2, w);
    
    x = s;
    y = s + w + s;
    
    ofSetLineWidth(20.0f);
    ofSetColor(100, 255, 255);
    ofPushMatrix();
    ofTranslate(x + (w/2), y + (w/2));
    	_polygon.draw();
    ofPopMatrix();
    
    x += w + s;
    
    ofPushMatrix();
    ofTranslate(x + (w/2), y + (w/2));
    	_star.draw();
    ofPopMatrix();
    
    x += w + w + s;
    y += w;
    
    ofPushMatrix();
    ofTranslate(x + (w/2), y + (w/2));
    	_curvedPath.draw();
    ofPopMatrix();
    
    ofSetColor(255, 255, 255);
    
    stringstream m;
    m << "FPS: " << (int)ofGetFrameRate();
    m << " | current renderer: ";
    m << (ofGetCurrentRenderer() == _defaultRenderer ? "DEFAULT" : "OFX_SHIVA_VG");
    m << " | click to toogle renderer";
    m << " | hit 'c' to toggle line-cap style";
    
    ofDrawBitmapString(m.str(), s, ofGetHeight() - s);
}
Example #24
0
//--------------------------------------------------------------
void cyrilApp::draw(){

  if (fxOn) {
    _state.post.begin();
  }

  ofEnableDepthTest();
  
  if (lightsOn) {
    _state.light->enable();
    // The default position of the light (apply z-scale)
    _state.light->setPosition(0,0,1000);
  }
  else {
    ofDisableLighting();
  }
  
  //ofEnableAlphaBlending();
  
  _state.ms->clearStacks();
  float X_MAX = (*_state.sym)[REG_X_MAX];
  float Y_MAX = (*_state.sym)[REG_Y_MAX];
  float X_MID = (*_state.sym)[REG_X_MID];
  float Y_MID = (*_state.sym)[REG_Y_MID];
  float X_SCALE = (*_state.sym)[REG_X_SCALE];
  float Y_SCALE = (*_state.sym)[REG_Y_SCALE];
  float Z_SCALE = (*_state.sym)[REG_Z_SCALE];
  
  for (int i = 0; i < 10; ++i) {
    if (running[i]) {
      if (prog[i]->valid) {
        ofPushMatrix();
        ofTranslate(X_MID, Y_MID);
        _state.ms->pushMatrix();
        _state.ms->translate(X_MID, Y_MID);
        
        ofScale(X_SCALE, Y_SCALE, Z_SCALE);
        _state.ms->scale(X_SCALE, Y_SCALE, Z_SCALE);
        
        
        prog[i]->eval(_state);
        
        _state.ms->popMatrix();
        ofPopMatrix();
      }
    }
  }
  
  for(vector<Particle*>::iterator it = _state.ps->begin(); it != _state.ps->end(); ++it){
    (*it)->draw(&_state);
  }
  
  if (lightsOn) {
    _state.light->disable();
  }
  
  
  if (fxOn) {
    _state.post.end();
  }
  
	//mainOutputSyphonServer.publishScreen();
  
  // Draw the editor if enabled
  if (editorVisible) {
    ofDisableDepthTest();
    ofPushMatrix();
    ofPushStyle();
    ofSetColor(255);
    ofFill();
  	editor.draw();
    ofTranslate(X_MID - 50, 10);
    for (int i = 0; i < 10; ++i) {
      if (error[i]) {
        ofSetColor(255,0,0);
      }
      else if (running[i]) {
        ofSetColor(255);
      }
      else {
        ofSetColor(150);
      }
      ofRect(i * 10, 0, 8, 8);
      if (editor.currentBuffer == i) {
        ofSetColor(255);
        ofRect(i * 10, 10, 8, 5);
      }
    }
    ofPopStyle();
    ofPopMatrix();
  }
  
}
Example #25
0
//--------------------------------------------------------------
void testApp::draw(){
    jonnysMovies.draw(0, 0, ofGetWidth(), ofGetHeight());
    
    
    if (oneOn == true) {
        
        ofSetColor(255, 255, 255);
        string user = "@" + twitter[1]["user"]["screen_name"].asString() + ":";
        font.drawString(user, 10, ofGetHeight()/5 - 50);
        
        ofSetColor(0,255,255);
        string message = twitter[1]["text"].asString();
        
        float messageWidth = font.stringWidth(message);
        if (messageWidth > ofGetWidth()-10) {
            string line1 = message.substr(0, 70);
            string line2 = message.substr(71, 70);
            
            font.drawString(line1, 10, ofGetHeight()/5);
            font.drawString(line2, 10, ofGetHeight()/5+50);
        }else {
            font.drawString(message, 10, ofGetHeight()/5);
        }
        
        
        ofSetColor(255, 255, 255);
    }else if (twoOn == true) {
        
        ofSetColor(255, 255, 255);
        string user = "@" + twitter[2]["user"]["screen_name"].asString() + ":";
        font.drawString(user, 10, 2*ofGetHeight()/5 - 50);
        
        ofSetColor(255,0,255);
        string message = twitter[2]["text"].asString();
        float messageWidth = font.stringWidth(message);
        if (messageWidth > ofGetWidth()-10) {
            string line1 = message.substr(0, 70);
            string line2 = message.substr(71, 70);
            
            font.drawString(line1, 10, 2*ofGetHeight()/5);
            font.drawString(line2, 10, 2*ofGetHeight()/5+50);
        }else {
            font.drawString(message, 10, 2*ofGetHeight()/5);
        } 
        
        ofSetColor(255, 255, 255);
    }else if (threeOn == true) {
        
        ofSetColor(255, 255, 255);
        string user = "@" + twitter[3]["user"]["screen_name"].asString() + ":";
        font.drawString(user, 10, 3*ofGetHeight()/5 - 50);
        
        ofSetColor(255,255,0);
        string message = twitter[3]["text"].asString();
        float messageWidth = font.stringWidth(message);
        if (messageWidth > ofGetWidth()-10) {
            string line1 = message.substr(0, 70);
            string line2 = message.substr(71, 70);
            
            font.drawString(line1, 10, 3*ofGetHeight()/5);
            font.drawString(line2, 10, 3*ofGetHeight()/5+50);
        }else {
            font.drawString(message, 10, 3*ofGetHeight()/5);
        }
        
        ofSetColor(255, 255, 255);
    }else if (fourOn == true) {
        
        ofSetColor(255, 255, 255);
        string user = "@" + twitter[4]["user"]["screen_name"].asString() + ":";
        font.drawString(user, 10, 4*ofGetHeight()/5 - 50);
        
        ofSetColor(200,200,200);
        string message = twitter[4]["text"].asString();
        float messageWidth = font.stringWidth(message);
        if (messageWidth > ofGetWidth()-10) {
            string line1 = message.substr(0, 70);
            string line2 = message.substr(71, 70);
            
            font.drawString(line1, 10, 4*ofGetHeight()/5);
            font.drawString(line2, 10, 4*ofGetHeight()/5+50);
        }else {
            font.drawString(message, 10, 4*ofGetHeight()/5);
        } 
        
        ofSetColor(255, 255, 255);
    }else if (sliderOn == true){
        ofSetColor(0, 0, 0);
        string feed = "#FEEDmixer";
        float mappedSize = ofMap(stringSize, 0, 127, 1, 5);
        
        float feedWidth = font.stringWidth(feed)/2;
        float feedHeight = font.stringHeight(feed)/2;
        
        float screenWidth = ofGetWidth()/2;
        float screenHeight = ofGetHeight()/2;
        
        float x = screenWidth-feedWidth;
        float y = screenHeight-feedHeight;
        
        ofSetRectMode(OF_RECTMODE_CENTER);
        ofPushMatrix();
            
            
            ofTranslate(screenWidth,screenHeight);
            ofScale(mappedSize, mappedSize);
            font.drawString(feed, 0-feedWidth, 0);
        
        ofPopMatrix();
        ofSetRectMode(OF_RECTMODE_CORNER);
        
        
        ofSetColor(255, 255, 255);
    }



}
Example #26
0
void ofxTLAudioTrack::draw(){
	
	if(!soundLoaded || player.getBuffer().size() == 0){
		ofPushStyle();
		ofSetColor(timeline->getColors().disabledColor);
		ofRectangle(bounds);
		ofPopStyle();
		return;
	}
		
	if(shouldRecomputePreview || viewIsDirty){
		recomputePreview();
	}

	//cout << "ofxTLAudioTrack::draw" << endl;

    ofSetColor(255, 255, 255, 205);
    ofFill();
    ofRect(bounds);
    ofPushStyle();
    //ofSetColor(timeline->getColors().keyColor);
    ofSetColor(0, 0 , 0, 255);
    ofNoFill();
    
    for(int i = 0; i < previews.size(); i++){
        ofPushMatrix();
        ofTranslate( normalizedXtoScreenX(computedZoomBounds.min, zoomBounds)  - normalizedXtoScreenX(zoomBounds.min, zoomBounds), 0, 0);
        ofScale(computedZoomBounds.span()/zoomBounds.span(), 1, 1);
        previews[i].draw();
        ofPopMatrix();
    }
    ofPopStyle();
	
	if(getIsPlaying() || timeline->getIsPlaying()){
		ofPushStyle();
		
		//will refresh fft bins for other calls too
		vector<float>& bins = getFFTSpectrum(defaultFFTBins);
		float binWidth = bounds.width / bins.size();
		//find max
		float averagebin = 0 ;
		for(int i = 0; i < bins.size(); i++){
			maxBinReceived = MAX(maxBinReceived, bins[i]);
			averagebin += bins[i];
		}
		averagebin /= bins.size();
		
		ofFill();
		ofSetColor(timeline->getColors().disabledColor, 120);
		for(int i = 0; i < bins.size(); i++){
			float height = bounds.height * bins[i]/maxBinReceived;
			float y = bounds.y + bounds.height - height;
			ofRect(bounds.x + i*binWidth, y, binWidth, height);
		}
		
		ofPopStyle();
	}

	// playhead 
	ofPushStyle();
	ofSetColor(0, 0, 0, 255);
	float x = normalizedXtoScreenX( oldpos, zoomBounds);
	ofLine(x, bounds.y, x, bounds.y + bounds.height);
	ofSetLineWidth(3);
	ofPopStyle();

	/*
	float pos = player.getPosition();
	if (pos) {
		ofxTLZoomer2D *zoom = (ofxTLZoomer2D*)timeline->getZoomer();
		ofRange z = zoom->getViewRange();
		ofRange oldz = z;
		float c = z.center(); 
		float d = pos - c;

		z.min = ofClamp(z.min + d, 0, 1); z.max = ofClamp(z.max + d, 0, 1);
		if (z.min == .0 && z.span() < oldz.span())
			z.max = oldz.max - oldz.min;
		if (z.max == 1. && z.span() < oldz.span())
			z.min = z.max - oldz.max + oldz.min;
	}*/




	// draw markers:
	for (vector<AlignMarker>::iterator m = markers.begin(); m != markers.end(); m++) {
		float xn = screenXtoNormalizedX(millisToScreenX(m->ms));
		if (zoomBounds.contains(xn)) {
			float x = timeline->normalizedXtoScreenX(xn, zoomBounds);
			if (m->selected)
				ofSetColor(255, 0, 0, 255);
			else 
				ofSetColor(0, 0, 0, 255);
			ofLine(x, bounds.y, x, bounds.y+bounds.height);
			m->rect = ofRectangle(x - 5, bounds.y + bounds.height - 12, 10, 10);
			ofSetColor(10, 0, 200, 100);
			ofFill();
			ofRect(m->rect);

			//cout << "m:" << m->ms << endl;
			ofSetColor(0, 0, 0, 255);
			timeline->getFont().drawString(ofToString(m->ms), x+1, bounds.y + 30);
		}
	}
	
}
Example #27
0
//--------------------------------------------------------------
void testApp::draw(){
	
	updateParticleSystem();
	updatePerlinLuminosity();

	renderTarget.begin();
	ofClear(0,0,0,255);
	cam.begin(ofRectangle(0,0,renderTarget.getWidth(), renderTarget.getHeight()));
			
    if(player.isLoaded()){
		drawGeometry();
	}

	ofPushMatrix();
//	ofScale(1,-1,1);
	ofTranslate(timeline.getValue("x offset"), 0, timeline.getValue("z offset"));
	glEnable(GL_DEPTH_TEST);
	ofEnableBlendMode(OF_BLENDMODE_SCREEN);
	
	ofSetColor(0);
	ofPushMatrix();
	ofScale(1, -1, 1);
	meshBuilder.getMesh().disableColors();
	meshBuilder.getMesh().draw();
	meshBuilder.getMesh().enableColors();
	ofPopMatrix();
	ofSetColor(255);
	
	ambientShader.begin();
	ofEnablePointSprites();
	ofDisableArbTex();
	crossSprite.getTextureReference().bind();
	
	ambientShader.setUniform1f("maxDisance", particleMaxDistance) ;
	ambientShader.setUniform1f("maxSize", particeMaxSize) ;

	ofEnableBlendMode(OF_BLENDMODE_SCREEN);
	ofPushStyle();
	glPointSize(3.0);
	ofSetColor(particleFade*255);
	ambientParticles.drawVertices();
	ofPopStyle();
	ambientShader.end();

	crossSprite.getTextureReference().unbind();
	
	glDisable(GL_DEPTH_TEST);
	ofDisablePointSprites();
	ofEnableArbTex();

	ofPopMatrix();
	
//	randomUnits.drawVertices();
//	clusters.drawVertices();

	cam.end();
	
	renderTarget.end();
	
	ofEnableAlphaBlending();
	ofPushStyle();
	ofSetColor(0);
	ofRect(fboRect);
	ofPopStyle();

	
	renderTarget.getTextureReference().draw(fboRect.x,fboRect.getBottom(),fboRect.width,-fboRect.height);
	
	if(rendering){

		saveImage.setUseTexture(false);
		renderTarget.readToPixels(saveImage.getPixelsRef());
		saveImage.mirror(true, false);
		char filename[1024];
		sprintf(filename, "%sframe_%05d.png",renderFolder.c_str(), currentFrameNumber);
		saveImage.saveImage(filename);
		currentFrameNumber++;
		
	}
	timeline.draw();
    gui.draw();
}
//--------------------------------------------------------------
void testApp::draw(){
    
    if (calibrateOn) drawGrid(); 
    if (calibrateOn) calibrate(); 
    drawText();
    
    
    //draw the cities------------------------------------------//
    ofPushMatrix(); 
    ofTranslate(gridX,gridY);
    ofScale(gridScaleX + scaleFactor, gridScaleY + scaleFactor);
    ofRotateZ(degreesFactor);
    ofEnableSmoothing();
    ofFill();

    for (int i = 0; i < 129; i++) {
        if (cities[i].isNear) {
            ofSetHexColor(0xe0be21);
        } else {
            ofSetColor(0);
        }
        cities[i].display(); 
    }
    ofFill();
    ofPopMatrix();
    
    
    //check distance------------------------------------------//
    for (int i = 0; i < 129; i++) {
        
        //we set the new coordinates of the cities to compare with mousePosition
        
        float loc_x_temp = cities[i].loc.x*(scaleFactor)+gridX;
        float loc_y_temp = cities[i].loc.y*(scaleFactor)+gridY;
        float d = ofDist(loc_x_temp, loc_y_temp,knob.x, knob.y); //magnitude
        
        
        if (rotation){
            ofVec2f locV(loc_x_temp,loc_y_temp);
            locV.rotate(degreesFactor);
            d= ofDist(locV.x, locV.y,knob.x, knob.y);
        }
        
        d = ofClamp(d, 0, 15);
        
        //add the station to the playlist. change later to "play"---------//
        if (d < 15) {
            int vol = ofMap(d, 0, 15, 100, 0);
            cities[i].volume = vol; 
            string setVol = "volume " + cities[i].volume; //for soundflower?
            
            cities[i].isNear = true;  
            
            if (!cities[i].isPlaying) {
                string command = "add " + cities[i].station;
                vlc.run(command); 
                nowPlaying = cities[i].name; 
                cities[i].isPlaying = true; 

            }
        } else {
            cities[i].isNear = false;  
            cities[i].isPlaying = false;              
        }
        
    }
    

    //tuio---------------------------//
    //render TUIO Cursors and Objects
	myTuio.drawCursors();
	myTuio.drawObjects();
    
    knob = myTuio.returnCursor();
    ofSetColor(100, 250, 100);
    ofCircle (knob.x, knob.y, 60); 
    

    
}
Example #29
0
void testApp::drawScene()
{

    light.enable();
    ofPushMatrix();
    
    
    ofScale(whole_scene_scale,whole_scene_scale,whole_scene_scale);
    ofRotateX(scene_rx);
    ofRotateY(scene_ry);
    ofRotateZ(scene_rz);
    ofTranslate(whole_scene_x, whole_scene_y, whole_scene_z);
    ofPushMatrix();

    
    ofVboMesh theCloud;
    theCloud.setUsage(GL_DYNAMIC_DRAW);
    theCloud.setMode(OF_PRIMITIVE_POINTS);
    theCloud.getNormals().resize(cloudField,ofVec3f(0));
    for (int i=0; i<cloud.size();i++) {
        theCloud.addVertex(cloud[i].location);
        theCloud.setNormal(i,ofVec3f(
                                     ofMap(meditationLevel, 0, 100, 5, 0)
                                     +ofNoise(ofGetElapsedTimef()+i),0,0));
        
    }
    
    billboardShader.begin();
    glDisable(GL_DEPTH_TEST);
    ofEnablePointSprites();
    texture.getTextureReference().bind();
    theCloud.draw();
    texture.getTextureReference().unbind();
    ofDisablePointSprites();
    billboardShader.end();
    glEnable(GL_DEPTH_TEST);
	ofPopMatrix();
    
    
    //   ----   room   ----
    
    if(showRoom){
        ofPushMatrix();
        ofEnableDepthTest();
        ofSetColor(255);
        ofRotateX(270);
        ofRotateY(roomRotateY);
        ofTranslate(roomModelPos);
        roomModel.draw();
        ofPopMatrix();
    }
    //   ----   end room   ----
    
    ofPushMatrix();
    drawPointCloud();
    ofPopMatrix();
#ifdef USE_TWO_KINECTS
    ofPushMatrix();
    drawAnotherPointCloud();
    ofPopMatrix();
#endif
    ofPopMatrix();
}
Example #30
0
//--------------------------------------------------------------
void Leaf::draw(){
    //DRAW STUFF
//    ofRect(xPos, yPos, 20, 40);
    
    //Draw leave
    
    //draw leaf left
    
    ofPushMatrix();
        ofTranslate(xPos, yPos);
        ofRotateZ(rotation);
        ofScale(scaleFactor, scaleFactor);
    
        ofSetColor(leafColor);
        ofBeginShape();
        
            float x0 = 0;
            float x1 = x0 - leafWidth/2;
            float x2 = x0 - leafWidth/4;
            float x3 = 0;
        
            float y0 = 0 + stemLength;
            float y1 = y0 + leafLength/3;
            float y2 = y1 + leafLength/3;
            float y3 = y0 + leafLength;
        
            ofVertex(x0,y0);
            ofBezierVertex(x1,y1,x2,y2,x3,y3);
        
        ofEndShape();

        //draw leaf right
        ofBeginShape();
        
            x0 = 0;
            x1 = x0 + leafWidth/2;
            x2 = x0 + leafWidth/4;
            x3 = 0;
            
            y0 = 0 + stemLength;
            y1 = y0 + leafLength/3;
            y2 = y1 + leafLength/3;
            y3 = y0 + leafLength;
            
            ofVertex(x0,y0);
            ofBezierVertex(x1,y1,x2,y2,x3,y3);
        
        ofEndShape();
        
        //draw stem
        ofSetColor(stemColor);
        ofRect(0, 0 + stemLength/2, stemWidth, stemLength);
        
        //triangular stem through leaf
        ofTriangle(0 - stemWidth/2, 0 + stemLength, 0 + stemWidth/2, 0 + stemLength, 0, 0 + stemLength + 2*(leafLength/3));
    
    
    ofPopMatrix();
    
    
    
    
}