コード例 #1
0
ファイル: ofImage.cpp プロジェクト: CNCBASHER/openFrameworks
void ofImage_<PixelType>::saveImage(string fileName, ofImageQualityType qualityLevel){
	ofSaveImage(pixels, fileName, qualityLevel);
}
コード例 #2
0
void ofImage_<PixelType>::save(ofBuffer & buffer, ofImageQualityType qualityLevel){
	ofSaveImage(pixels, buffer, qualityLevel);
}
コード例 #3
0
void ofImage_<PixelType>::save(const ofFile & file, ofImageQualityType compressionLevel){
	ofSaveImage(pixels,file.getAbsolutePath(),compressionLevel);
}
コード例 #4
0
ファイル: ofImage.cpp プロジェクト: 2bbb/openFrameworks
bool ofImage_<PixelType>::save(const std::filesystem::path& fileName, ofImageQualityType qualityLevel) const {
	return ofSaveImage(pixels, fileName, qualityLevel);
}
コード例 #5
0
ファイル: ofImage.cpp プロジェクト: 2bbb/openFrameworks
bool ofImage_<PixelType>::save(ofBuffer & buffer, ofImageFormat imageFormat, ofImageQualityType qualityLevel) const {
	return ofSaveImage(pixels, buffer, imageFormat, qualityLevel);
}
コード例 #6
0
ファイル: ofApp.cpp プロジェクト: anwar-hegazy/Oscilloscope
//--------------------------------------------------------------
void ofApp::draw(){
	ofClear(0,255);
	
	if( !fbo.isAllocated() || fbo.getWidth() != ofGetWidth() || fbo.getHeight() != ofGetHeight() ){
		int w = ofGetWidth(); 
		int h = ofGetHeight();
		if( exporting ){
			// no need to do anything, fbo is managed by someone else
		}
		else if( w == 0 || h == 0 ){
			//what is happening???
			while( globals.player.left192.totalLength > 4096 && globals.player.right192.totalLength > 4096 ){
				globals.player.left192.peel(4096);
				globals.player.right192.peel(4096);
			}
		}
		else{
			cout << "allocating framebuffer with " << w << ", " << h << endl; 
			fbo.allocate(ofGetWidth(), ofGetHeight(),GL_RGBA);
			fbo.begin();
			ofClear(0,255);
			fbo.end();
		}
	}
	
	if( changed && globals.player.isPlaying ){
		fbo.begin();
		ofEnableBlendMode(OF_BLENDMODE_MULTIPLY);
		ofSetColor( 0, (1-globals.afterglow)*255 );
		ofFill();
		ofRect( 0, 0, fbo.getWidth(), fbo.getHeight() );
	
		ofEnableAlphaBlending();
		ofMatrix4x4 viewMatrix = getViewMatrix();

//      TODO: draw the cross section
//		ofSetColor(255, 0, 0, 25);
//		ofDrawLine( -10, 0, 10, 0 );
//		ofDrawLine( 0, -10, 0, 10 );
		
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE);
		shader.begin();
		shader.setUniform1f("uSize", globals.strokeWeight / 1000.0);
		shader.setUniform1f("uIntensity", globals.intensity);
		shader.setUniformMatrix4f("uMatrix", viewMatrix);
		shader.setUniform1f("uHue", globals.hue );
		ofSetColor(255);
		shapeMesh.draw();
		shader.end();
		ofEnableAlphaBlending();

		fbo.end();
	}
	
	ofSetColor(255);
	fbo.draw(0,0);
	
	if( exporting >= 2 ){
		string filename = ofToDataPath(exportDir + "/" + ofToString(exportFrameNum, 5, '0') + ".png");
		ofPixels pixels;
		fbo.readToPixels(pixels);
		ofSaveImage(pixels, filename);
	}
	
	if( showInfo || exporting > 0 ){
		ofSetColor(exporting>0?255:100);
		ofDrawBitmapString("Dropped: " + ofToString(dropped), 10, 20 );
		ofDrawBitmapString("FPS:     " + ofToString(ofGetFrameRate(),0), 10, 40 );
		
		if( exporting > 0 ){
			unsigned long long totalFrames = 1+globals.player.duration*globals.exportFrameRate/1000;
			int pct = exportFrameNum*100/totalFrames;
			ofDrawBitmapString("Format:  " + ofToString(globals.exportWidth) + " x " + ofToString(globals.exportHeight) + " @ " + ofToString(globals.exportFrameRate) + "fps (change in data/settings.txt)", 10, 60);
			ofDrawBitmapString("Export:  " + ofToString(pct) + "%  (" + ofToString(exportFrameNum) + "/" + ofToString(totalFrames) + ")", 10, 80 );
			if( (exportFrameNum%10) < 5 ){
				ofSetColor(255,0,0);
			}
			else{
				ofSetColor(255);
			}
			ofFill();
			ofEllipse(20, 100, 20, 20);
		}
	}
}
コード例 #7
0
ファイル: ofApp.cpp プロジェクト: aferriss/mdAtl
//--------------------------------------------------------------
void ofApp::drawCubeMap(){
    ofTexture pp, pp2, pp3, pp4, pp5, pp6;
    
    saveFbo.begin();
    
    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[0], axis[0]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp = postProcess(cubeFbo.getTexture());
    pp.draw(cubeSize, cubeSize, cubeSize, cubeSize);
    
    
    
    
    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[1], axis[1]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp2 = postProcess(cubeFbo.getTexture());
    pp2.draw(cubeSize, 0, cubeSize, cubeSize);
    
    
    
    
    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[2], axis[2]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp3 = postProcess(cubeFbo.getTexture());
    pp3.draw(cubeSize, cubeSize*2, cubeSize, cubeSize);
    
    
    
    
    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[3], axis[3]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp4 = postProcess(cubeFbo.getTexture());
    pp4.draw(cubeSize*2, cubeSize, cubeSize, cubeSize);
    
    
    

    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[4], axis[4]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp5 = postProcess(cubeFbo.getTexture());
    pp5.draw(cubeSize*3, cubeSize, cubeSize, cubeSize);

    
    
    
    cubeCamera.setGlobalPosition(0, 0, 0);
    cubeFbo.begin();
    ofClear(0);
    cubeCamera.setOrientation(ofQuaternion(degrees[5], axis[5]));
    cubeCamera.begin();
    draw3dScene();
    cubeCamera.end();
    cubeFbo.end();
    
    pp6 = postProcess(cubeFbo.getTexture());
    pp6.draw(0,cubeSize, cubeSize, cubeSize);
    
    
    
    
    saveFbo.end();
    

    
    saveFbo.readToPixels(savePix);

    ofSaveImage(savePix, "cubeImages/final/ch13_"+ofToString(inc)+".tga");
    inc++;
    
    
    saveFbo.draw(0,0, w, h);
    
    //video.nextFrame();
}
コード例 #8
0
ファイル: ofApp.cpp プロジェクト: paulobarcelos/Movie2Sprite
//--------------------------------------------------------------
void ofApp::setup() {
    ofDirectory dir;
    ofVideoPlayer player;

    int edge = 2;

    ofxXmlSettings settings;
    settings.loadFile("settings.xml");


    ofVec2f movieSize(settings.getValue("movieSize:width", 128) + edge,
                      settings.getValue("movieSize:height", 128) + edge);
    ofVec2f texSize(settings.getValue("texSize:width", 1024),
                    settings.getValue("texSize:height", 1024));
    float duration = settings.getValue("duration", 1.0);
    float fps = settings.getValue("fps", 1.0);

    int numFrames = duration * fps;
    int numMovies = dir.listDir("movies");
    int totalFrames = numFrames * numMovies;

    float movieRatio = movieSize.x / movieSize.y;

    float texArea = texSize.x * texSize.y;
    float fitArea = texArea / (float)totalFrames;

    float fitHeight = sqrt(fitArea/movieRatio);
    float fitWidth = fitArea/fitHeight;

    ofVec2f fitSize(fitWidth,
                    fitHeight);

    ofVec2f numUnits(ceil(texSize.x / fitSize.x),
                     ceil(texSize.y / fitSize.y));

    ofVec2f size = texSize / numUnits;
    ofVec2f scale = movieSize / size;

    ofFile::removeFile("sprite.js");
    ofstream js;
    js.open (ofToDataPath("sprite.js").c_str(), std::ios::out | std::ios::app);
    js << "var sprite={coordinates:[";

    ofFbo fbo;
    fbo.allocate(texSize.x, texSize.y);
    fbo.begin();
    ofClear(0, 0, 0, 0);
    fbo.end();

    float column = -1;
    float row = -1;
    int frameIndex = 0;

    for (float i = 0; i < numMovies; i++) {
        player.loadMovie(dir.getPath(i));
        cout << dir.getPath(i) << endl;
        int playerNumFrames = player.getTotalNumFrames();
        float offset = (float)playerNumFrames / (float)numFrames;

        js << "[";
        for (float j = 0; j < numFrames; j++) {
            column = frameIndex % (int)numUnits.x;
            if(column == 0) row++;

            js << "\"-" << (column * movieSize.x) << "px -" << (row * movieSize.y) << "px\"";
            if(j < numFrames-1) js << ",";

            player.setFrame(j * offset+1);
            player.update();
            fbo.begin();
            player.draw(floor(column * size.x), floor(row * size.y), ceil(size.x), ceil(size.y));
            fbo.end();

            frameIndex++;
        }
        js << "]";
        if(i < numMovies-1) js << ",";

    }

    js << "]";
    js << ",duration:" << duration;
    js << ",image:\"sprite.png\"";
    js << ",numFrames:" << numFrames;
    js << ",numMovies:" << numMovies;
    js << ",width:" << movieSize.x - edge;
    js << ",height:" << movieSize.y - edge;
    js << ",backgroundSize:\"" << (texSize.x * scale.x) << "px " << (texSize.y * scale.y)<< "px\"";
    js << "};";
    js.close();

    ofPixels pixels;
    pixels.allocate(texSize.x, texSize.y, 4);
    fbo.readToPixels(pixels);
    ofSaveImage(pixels, "sprite.png");

    ofExit(0);
}
コード例 #9
0
ファイル: ofxJpegGlitch.cpp プロジェクト: 2bbb/ofxJpegGlitch
void ofxJpegGlitch::setPixels(ofPixelsRef pix) {
    ofSaveImage(pix, buf, OF_IMAGE_FORMAT_JPEG);
}
コード例 #10
0
ファイル: ofxJpegGlitch.cpp プロジェクト: 2bbb/ofxJpegGlitch
void ofxJpegGlitch::setImage(ofImage &image) {
    ofSaveImage(image.getPixelsRef(), buf, OF_IMAGE_FORMAT_JPEG);
}
コード例 #11
0
//--------------------------------------------------------------
void testApp::update(){
	this->guiRecordStateLabel->setLabel(Stream::Recorder::toString(this->recorder.getState()));
	this->guiDeviceStateLabel->setLabel(toString(grabber.getDeviceState()));
	this->guiRecordCountLabel->setLabel("Frame count: " + ofToString(this->recorder.size()));

	if (this->toggleRecord != this->recorder.getIsRecording()) {
		if (this->toggleRecord) {
			this->recorder.start();
		} else {
			this->recorder.stop(); 
		}
	}

	if (this->bangClear) {
		this->recorder.clear();
		this->selectionView.clear();
	}

	if (this->bangClearBefore) {
		auto it = this->recorder.lower_bound(this->selectionTimestamp);
		while (it != this->recorder.end()) {
			this->recorder.erase(it);
			it = this->recorder.lower_bound(this->selectionTimestamp);
		}
	}

	if (this->bangClearAfter) {
		auto it = this->recorder.upper_bound(this->selectionTimestamp);
		while (it != this->recorder.end()) {
			this->recorder.erase(it);
			it = this->recorder.upper_bound(this->selectionTimestamp);
		}
	}
	
	if (this->bangSavePipets) {
		ofFile file;
		file.open("pipets.txt", ofFile::WriteOnly, false);
		for (auto it : this->recorder) {
			file << it.first << "\t";

			for (auto pipet : this->pipets) {
				file << (int) this->getValue(it.first, pipet) << "\t";
			}

			file << endl;
		}
		file.close();
	}

	if (!this->recorder.getIsRecording()) {
		this->grabber.update();
	}

	if (this->toggleSave) {
		auto & pixels = this->recorder[this->selectionTimestamp].getPixelsRef();
		ofSaveImage(pixels, ofToString(this->selectionTimestamp) + ".png");
	}

	if (this->toggleProgress && ! this->recorder.empty()) {
		auto nextFrame = this->recorder.upper_bound(this->selectionTimestamp);
		if (nextFrame == this->recorder.end()) {
			nextFrame = this->recorder.begin();
		}
		this->selectionTimestamp = nextFrame->first;
		this->loadSelection();
	} else {
		this->toggleSave = false;
	}
}
コード例 #12
0
void testApp::update() {
	
//	for (int deviceID = 0; deviceID < numDevices; deviceID++){
//		if(openNIDevices[deviceID]->update()){
//			cout << "UPDATED " << deviceID << endl;
//		}
//	}
	
	front.update();
	if(front.isFrameNew()){
		
		compressor.convertTo8BitImage(front.getRawDepth(), depthImage1);

		contourFinder.setThreshold(threshold);
		contourFinder.setMinArea(minSize);
		contourFinder.findContours(depthImage1);
		if(contourFinder.size() > 0){
			int maxAreaIndex = 0;
			float maxArea = 0;

			for(int i = 0; i < contourFinder.size(); i++) {
				if(maxArea < contourFinder.getBoundingRect(i).area()){
					maxArea	 = contourFinder.getBoundingRect(i).area();
					maxAreaIndex = i;
				}
			}
			ofPoint center = ofxCv::toOf( contourFinder.getCenter(maxAreaIndex) );
			areaDepth =  depthImage1.getColor( center.x, center.y ).getBrightness();
			//cout << "depth? " << areaDepth << endl;
			if(areaDepth > minTriggerDepth && areaDepth < maxTriggerDepth){
				ghostFrames = 0;
				if(!inThreshold){
					thresholdEnteredTime = ofGetElapsedTimef();
					inThreshold = true;
				}
				float timeInThreshold = ofGetElapsedTimef() - thresholdEnteredTime;
//				cout << "time in threshold " << timeInThreshold << endl;
				if(timeInThreshold > requiredThresholdTime){
					shouldFireCamera = true;
					requiredThresholdTime = 7;
					inThreshold = false;
					cout << "FIRING CAMERA!" << endl;
				}
			}
			else {
				if(ghostFrames++ > 5){
					requiredThresholdTime = 2;
					inThreshold = false;
				}
			}
		}
		else {
			if(inThreshold && ghostFrames++ > 5){
				inThreshold = false;
				requiredThresholdTime = 2;
			}
		}
		
		if( (showRGBD && alwaysUpdate) || (pullFrontRender && (ofGetElapsedTimef() - cameraFiredTime) > delay) ){
			pullFrontRender = false;
			renderer1.update();
			cout << "front renderer pulled after " << ofGetElapsedTimef() - cameraFiredTime << endl;
		}
		
		//cout << "found " << contourFinder.size() << endl;
		/*
		for(int y = 0; y < 640; y+=2){
			for(int x = 0; x < 480; x++){
				
			}
		}
		 */
	}
	
	back.update();
	if(back.isFrameNew()){
		
		compressor.convertTo8BitImage(back.getRawDepth(), depthImage2);
		
		backContourFinder.setThreshold(threshold);
		backContourFinder.setMinArea(minSize);
		
		backContourFinder.findContours(depthImage2);

		if((pullBackRender && (ofGetElapsedTimef() - cameraFiredTime) > delay) || (showRGBD && alwaysUpdate) ){
			pullBackRender = false;
			renderer2.update();
			cout << "back renderer pulled after " << ofGetElapsedTimef() - cameraFiredTime << endl;
		}
	}
	
	camera1.update();
//	if(camera1.isFrameNew()) {
//		// process the live view with camera.getLivePixels()
//		pix.setFromPixels(camera1.getLivePixels());
//	}
	
	if(renderer1.shift.x != xshift ||
	   renderer1.shift.y != yshift ||
	   renderer1.edgeClip != edgeClip ||
	   renderer2.edgeClip != edgeClip)
	{
		renderer1.edgeClip = edgeClip;
		renderer2.edgeClip = edgeClip;
		
		renderer1.shift = ofVec2f(xshift,yshift);
		
		filler.close(renderer1.getDepthImage());
		
		renderer1.update();
	}
	
	if(camera1.isPhotoNew()) {
		// process the photo with camera.getPhotoPixels()
		// or just save the photo to disk (jpg only):
		cout << "saved camera 1 photo" << endl;

		if(renderer1.hasTriangles && renderer2.hasTriangles){

			camera1.getPhotoPixels().resize(696, 464);
			ofSaveImage(camera1.getPhotoPixels(), currentSaveDirectory + "/photo.jpg");
			saveCombinedMesh( currentSaveDirectory + "/mesh.obj" );

			ofxOscMessage m;
			m.setAddress("/mesh");
			m.addStringArg("file://"+currentSaveDirectory);
			sender.sendMessage(m);

			//camera1.savePhoto(currentSaveDirectory + "/photo.jpg");
			
			cout << "*** Message finally sent after " << ofGetElapsedTimef() - cameraFiredTime << endl;
		}
		
		if(showRGBD){
			photoPreview.setFromPixels(camera1.getPhotoPixels());
			renderer1.update();
		}
		inThreshold = false;
	}
	
	    
/*
	camera2.update();
	if(camera2.isFrameNew()) {
		// process the live view with camera.getLivePixels()
		pix.setFromPixels(camera2.getLivePixels());
	}
	if(camera2.isPhotoNew()) {
		// process the photo with camera.getPhotoPixels()
		// or just save the photo to disk (jpg only):
		cout << "saved camera 2 photo" << endl;
		camera2.savePhoto(ofToString(ofGetFrameNum()) + ".jpg");
	}
*/
	
	if(autoFire && shouldFireCamera){
		fireCamera();
	}
}