void VideoBuffer::setFramePos(float posPerc) {
    
    float outVal = posPerc * (float)(size()-1);    // convert percentage to numFrames
    float tempVal = floor(outVal+0.5);             // used to round float to next int
    
    if(tempVal==lastVal){
        framePos = tempVal+1;         // If the percenatge to frames = name int as last time +1
        //cout << "frames Pos = " << framePos << " --- " << "lastVal = " << lastVal << " --- " << "tempVal + 1 = " << tempVal + 1;
    } else if(tempVal-lastVal==1){
        framePos = tempVal;           // else use the rounded value
        //cout << "frames Pos = " << framePos << " --- " << "lastVal = " << lastVal << " --- " << "tempVal = " << tempVal;
    } else {
        framePos = outVal;            // else percentage to frame converstion was correct
        //cout << "frames Pos = " << framePos << " --- " << "lastVal = " << lastVal << " --- " << "outVal = " << outVal;
    }
    
    // If the audio rec position conversion is greater than a single frame, or if the framerate changes
    // work out the dirreference and paste the previous frame accross to avoid all glitches :)
    
    int diff = ofWrap(framePos-lastVal, 0, size());
    if(diff>1 && lastVal <= framePos){
        for(int i = lastVal; i < lastVal+diff; i++){
           // cout << "FRAMEPOS = " << framePos << " -- " << "LAST VAL = " << lastVal << " -- " << "DIFF = " << diff << " -- " << "LAST VAL + DIFF = " << lastVal+diff << " -- " << "framePos - lastVal = " << framePos - lastVal << endl;

            frames[ofWrap(i,0,size())] = frames[lastVal];
        }
    }

    lastVal = framePos;   // Store the last truncated integer
}
Exemple #2
0
void Lyu::ArcBarNode::customDraw()
{
  if(TimeStart<=0)
  {
    TimeStart = ofGetElapsedTimef();
    return;
  }

  float TimeNow = ofGetElapsedTimef();
  float PassedTime = TimeNow-TimeStart;
  float TimeNorm = StartPct+PassedTime/Duration;
  float pct(0);
  if(WMode==WrapMode::CLAMP)
  {
    pct = ofClamp(TimeNorm,0,1);
  }
  else if(WMode==WrapMode::REPEAT)
  {
    pct = ofWrap(TimeNorm,0,1);
  }
  else if(WMode==WrapMode::MIRRORED_REPEAT)
  {
    pct = ofWrap(TimeNorm,0,2);
    pct = pct>1.0f?2.0f-pct:pct;
  }
  
  float deg = pct*360.0f;  
  
  ofPath P;
  
  float degStep = 360.0f/CircleRes;

  int IterNum = ceil(deg/degStep);
  float degStep2 = deg/IterNum;
  for(int i=0;i<=IterNum;i++)
  {
    float rad = ofDegToRad(degStep2*i);
    float x = Radius[0]*cos(rad);
    float y = Radius[0]*sin(rad);
    P.lineTo(ofVec2f(x,y));
  }  
  for(int i=IterNum;i>=0;i--)
  {
    float rad = ofDegToRad(degStep2*i);
    float x = Radius[1]*cos(rad);
    float y = Radius[1]*sin(rad);
    P.lineTo(ofVec2f(x,y));
  }
  P.lineTo(ofVec2f(Radius[0],0));
  P.setColor(Cr);

  ofPushStyle();
  ofFill();
  P.draw();  
  ofPopStyle();
}
SharedPtrColVec ComplimentaryPalette::createPalette(const ofColor & _seedColour) {
  seedColour = _seedColour;

  vector<float> hues; // stores the hue values
  float ang = seedColour.getHueAngle(); // hue angle of the seed colour
  float s = seedColour.getSaturation();
  float b = seedColour.getBrightness();

  ang = ofMap(ang, 0, 360, 0, 255); // map from angle to HSB colour space min and max.

  float compHue = ofWrap(ang + 127.5, 0, 255); // The complimentary hue's colour.

  colours->push_back( ofColor::fromHsb( ang, s, b ) );
  colours->push_back( ofColor::fromHsb( ang, ofWrap(s + 15, 0, 255), ofWrap(b + 15, 0, 255) ) );
  colours->push_back( ofColor::fromHsb( ang, ofWrap(s - 15, 0, 255), ofWrap(b - 15, 0, 255) ) );
  colours->push_back( ofColor::fromHsb( compHue, ofWrap(s + 15, 0, 255), ofWrap(b + 15, 0, 255) ) );
  colours->push_back( ofColor::fromHsb( compHue, ofWrap(s - 15, 0, 255), ofWrap(b - 15, 0, 255) ) );

  return colours;
}
void ConnectionTracerRenderer
::drawTracer(const AbstractConnection& connection,
             std::shared_ptr<ofBaseRenderer>& renderer) {
  if (!connection.visible()) {
    return;
  }
  auto ratio = ofWrap(_rawRatio
                      + static_cast<float>(connection.entityId() % 12) / 12.0f,
                      0, 1);

  auto tracerPos = connection.evaluatePosition(ratio);
  const auto& entityA = connection.sourceEntity();
  const auto& entityB = connection.targetEntity();
  auto color = getInterpolated(entityA.color(), entityB.color(), ratio);
  color.setBrightness(color.getBrightness() * 1.2);
  color.a *= getInterpolated(entityA.alpha(),
                             entityB.alpha(),
                             ratio);
  color.a *= _params.alphaFade.evaluate(ratio);
  renderer->setColor(color);
  renderer->drawBox(tracerPos,
                    _params.drawRadius.get());
}
Exemple #5
0
float ofWrapDegrees(float angle, float from, float to){
	return ofWrap(angle, from, to);
}
Exemple #6
0
//--------------------------------------------------
float ofWrapRadians(float angle, float from, float to){
	return ofWrap(angle, from, to);
}
//----------------------------------------------------------
// wraps any radian angle -FLT_MAX to +FLT_MAX into 0->2PI range.
// TODO, make angle treatment consistent across all functions
// should always be radians?  or should this take degrees?
// used internally, so perhaps not as important
float ofPolyline::wrapAngle(float angleRadians) {
	return ofWrap(angleRadians, 0.0f, TWO_PI);
}
void ofApp::keyPressed(int key){
    if(key>='0' && key<='9'){
        cycle_disp_mode = int(key)-48;
        cout<<"cycle display mode: "<<cycle_disp_mode<<endl;
    }
    if(key=='a'){
        mute = !mute;
    }
/*    if(key=='b'){
        disp_buf = ofWrap(disp_buf+1, 0, 3);
        cout<<"display buffer: "<<disp_buf<<endl;
    }*/
    if(key=='c'){
        draw_offset.x = draw_offset.y = 0;
    }
    if(key=='d'){
        disp_mode = (disp_mode+1)%display_sequence.size();
        cout<<"display mode: "<<disp_mode<<endl;
    }
    if(key=='f'){
        fullscreen = !fullscreen;
        ofSetFullscreen(fullscreen);
    }
    if(key=='h'){
        usage();
    }
    if(key=='i'){
        integrator = 1-integrator;
        cout<<"integrator: "<<integrator<<endl;
    }
    if(key=='l'){
        /*cout<<"reload shaders"<<endl;
        loadShaders();
        */
    }
    if(key=='p'){
        disp_scale = ofWrap(disp_scale+1, 0, num_scales);
        cout<<"display scale: "<<disp_scale<<endl;
    }
    if(key=='s'){
        save_frame = true;
    }
    if(key=='r'){
        forward_graph->initFbos();
        vwt->scramble();
    }
    if(key==']'){
        setResolution(fbo_params.width*2, fbo_params.height*2);
        cout<<"new resolution: "<<fbo_params.width<<" by "<<fbo_params.height<<endl;
    }
    if(key=='['){
        if(fbo_params.width>1 && fbo_params.height>1)
            setResolution(fbo_params.width/2, fbo_params.height/2);
        cout<<"new resolution: "<<fbo_params.width<<" by "<<fbo_params.height<<endl;
    }
    if(key=='n'){ //for testing purposes
        setResolution(fbo_params.width, fbo_params.height);
        cout<<"call setResolution() with current resolution"<<endl;
    }
    if(key=='m'){
        toggleRenderMode();
    }
    if(key=='v'){
        toggleVideoRecord();
    }
}
//--------------------------------------------------------------
void testApp::update()
{
	ofBackground(ofColor::black);

	// grab new frame and update colorImg with it.
    bool bNewFrame = false;

	#ifdef _USE_LIVE_VIDEO
       vidGrabber.update();
	   bNewFrame = vidGrabber.isFrameNew();
    #else
        vidPlayer.update();
        bNewFrame = vidPlayer.isFrameNew();
	#endif

	if (bNewFrame)
	{
		
		#ifdef _USE_LIVE_VIDEO
            colorImg.setFromPixels(vidGrabber.getPixels(), 320,240);
	    #else
            colorImg.setFromPixels(vidPlayer.getPixels(), 320,240);
        #endif

        grayImage = colorImg; // converts from color to greyscale

		float time = ofGetElapsedTimef();

		// Update mesh from grayImage's pixels
		updateMesh();
		
		// update a few variables based on time
		float timeToChangePalettes = 10.0f;
		int paletteIndex = (int) ((ofWrap( time, 0.0f, timeToChangePalettes ) / timeToChangePalettes ) * palettes.size());
		if( palettes.size() > 0 && paletteIndex < palettes.size())  currPalette = &palettes.at(paletteIndex);
			
		linesHeight = 80.0f;
		
		lineSkip = 4; //ofMap( cos(time * 1.1f), -1.0f, 1.0f, 2, 25 );
		
		// if we click, wait a bit until we auto orbit the camera
		if( (time - lastClickTime) > 4.0 )
		{
			float orbitLong = ofMap( ofNoise(time*0.2f), 0.0f, 1.0f, -50.0f, 50.0f ) ;
			float orbitLat = ofMap( ofNoise( (time+111.0f)*0.3f), 0.0f, 1.0f, 0.0f, -100.0f ) ;
			float orbitRadius = ofMap( ofNoise( (time-123.0f)*0.45f), 0.0f, 1.0f, 100.0f, 250.0f ) ;
			camera.orbit(orbitLong, orbitLat, orbitRadius );
		}
		
		fbo.begin();
			ofClear(0, 0, 0, 0); //clear our Fbo memory
			ofEnableDepthTest(); //enable 3d
				camera.begin(); //start our camera viewpoint
					ofTranslate( 
								(grayImage.getWidth() * -0.5f) * imageToSpaceScaling.x, //move x
								0.0f,													//move y
								(grayImage.getHeight() * -0.5f) * imageToSpaceScaling.z //move z
								);
			
					ofSetColor( ofColor::white );	//start with a white mesh
					colorFromHeightShader.begin();	//begin our shader
						if( currPalette != NULL )	//make sure we have a palette
						{
							//we pass our palette to the shader
							colorFromHeightShader.setUniformTexture( "u_paletteSampler", currPalette->getTextureReference(), 1 ); 
						}
						//we pass our linesHeight to the shader
						colorFromHeightShader.setUniform1f("u_maxHeight", linesHeight );
		
						//we draw our mesh (currently in OF_PRIMITIVE_LINES mode)
						mesh.draw();
					colorFromHeightShader.end();	//stop our shader operation
				camera.end();						//end our camera view
			ofDisableDepthTest();					//ending 3d
		fbo.end();									//stop drawing inside the fbo
	}
}
//--------------------------------------------------------------
void GrainPlayer::setPositionRandom(float _val){
    grainPosition = ofWrap(playHead + (ofRandom(0.0,_val)),0.0,1.0);
}