Annonce

>>> Bienvenue sur codelab! >>> Première visite ? >>> quelques mots sur codelab //// partage de liens //// une carte des membres//// (apéros) codelab


#1 2014-07-25 14:50:29 ofTexture to ofImage

caracteriel
membre
Date d'inscription: 2011-07-03
Messages: 129

ofTexture to ofImage



Salut,

  Quelqu'un saurait comment on transforme un ofTexture en image ?
Ou comment récupérer les points de ofTexture en pixel.
En fait pour le dernier point, j'ai fait un truc qui était censé fonctionner :
j'ai un fluxCamera qui est déclaré en ofVideograbber.

Le truc que l'on fait sur linux c'est juste un : ofPixelsRef pixelsLum =  fluxCamera.getPixelsRef();
du coup pixelsLum a les mêmes propriétés qu'une photo.
mais sur Ios me renvoie rien fluxCamera.getPixelsRef();
sans doute pour des questions de format.

Donc du coup, j'ai pix = fluxCamera.getPixels(); avec pix qui est déclaré unsigned char *pix

et pour récupérer les couleurs des pixels du flux de la camera, j'ai fait un

for(int height= 0 ; height<cameraH ; height+=14)
        for(int width = 0 ; width<cameraW ; width+=10){

            ofColor couleur =ofColor(pix[height*fluxCamera.width + width], pix[height*fluxCamera.width+width+1], pix[height*fluxCamera.width+width+2]);

            ofSetColor(couleur);
}
Mais forcément ça ne marche pas vu que le flux que je récupère n'est pas du RGB, par contre le flux je peux le placer sur une texture avec les paramètres RGB en faisant un :

tex.loadData(pix, fluxCamera.getWidth(),  fluxCamera.getHeight(), GL_RGB);

Donc, j'aimerais pouvoir interpréter ma texture pour pouvoir utiliser des pixels et tout
J'espère ne pas avoir été trop brouillon dans mon explication

Hors ligne

 

#2 2014-07-25 17:51:28 Re : ofTexture to ofImage

Mushussu
membre
Lieu: Orléans
Date d'inscription: 2012-05-24
Messages: 732

Re: ofTexture to ofImage



Bonjour,

Je n'ai pas bien saisi ta démarche. Voici un bout de code qui utilise getPixels() et la manipulation des pixels :

//--------------------------------------------------------------
void testApp::setup(){
	
	camWidth 		= 320;
	camHeight 		= 240;
	
	vidGrabber.setVerbose(true);
	vidGrabber.setDeviceID(0);
	vidGrabber.setDesiredFrameRate(60);
	vidGrabber.initGrabber(camWidth,camHeight);
	
	videoRot90 	= new unsigned char[camWidth*camHeight*3];
	videoRot180 = new unsigned char[camWidth*camHeight*3];
	videoRot270 = new unsigned char[camWidth*camHeight*3];
	verticalFlip = new unsigned char[camWidth*camHeight*3];
	horizontalFlip = new unsigned char[camWidth*camHeight*3];
	
	videoTexture90.allocate(camHeight, camWidth, GL_RGB);
	videoTexture180.allocate(camWidth, camHeight, GL_RGB);
	videoTexture270.allocate(camHeight, camWidth, GL_RGB);
	verticalFlipTexture.allocate(camWidth, camHeight, GL_RGB);
	horizontalFlipTexture.allocate(camWidth, camHeight, GL_RGB);
	
	ofSetVerticalSync(true);
}


//--------------------------------------------------------------
void testApp::update(){
	
	ofBackground(100,100,100);
	
	vidGrabber.update();
	
	if (vidGrabber.isFrameNew()){
		unsigned char * pixels = vidGrabber.getPixels();
		for (int i = 0; i < 3 * camWidth; i += 3){
			for (int j = 0; j < camHeight; j++) {
				// Rotation 90
				videoRot90[(camWidth - (i / 3) - 1) * 3 * camHeight + 3 * j] = pixels[j * 3 * camWidth + i];
				videoRot90[(camWidth - (i / 3) - 1) * 3 * camHeight + 3 * j + 1] = pixels[j * 3 * camWidth + i + 1];
				videoRot90[(camWidth - (i / 3) - 1) * 3 * camHeight + 3 * j + 2] = pixels[j * 3 * camWidth + i + 2];
				
				// Rotation 180
				videoRot180[(camHeight - j - 1) * 3 * camWidth + 3 * (camWidth - 1) - i] = pixels[j * 3 * camWidth + i];
				videoRot180[(camHeight - j - 1) * 3 * camWidth + 3 * (camWidth - 1) - i + 1] = pixels[j * 3 * camWidth + i + 1];
				videoRot180[(camHeight - j - 1) * 3 * camWidth + 3 * (camWidth - 1) - i + 2] = pixels[j * 3 * camWidth + i + 2];
				
				// Rotation 270
				videoRot270[((i / 3)) * 3 * camHeight + 3 * (camHeight - j - 1)] = pixels[j * 3 * camWidth + i];
				videoRot270[((i / 3)) * 3 * camHeight + 3 * (camHeight - j - 1) + 1] = pixels[j * 3 * camWidth + i + 1];
				videoRot270[((i / 3)) * 3 * camHeight + 3 * (camHeight - j - 1) + 2] = pixels[j * 3 * camWidth + i + 2];
				
				// Vertical Flip
				verticalFlip[(camHeight - j - 1) * 3 * camWidth + i] =     pixels[j * 3 * camWidth + i];
				verticalFlip[(camHeight - j - 1) * 3 * camWidth + i + 1] = pixels[j * 3 * camWidth + i + 1];
				verticalFlip[(camHeight - j - 1) * 3 * camWidth + i + 2] = pixels[j * 3 * camWidth + i + 2];
				
				// HorizontalFlip
				horizontalFlip[j * 3 * camWidth + 3 * (camWidth - 1) - i] = pixels[j * 3 * camWidth + i];
				horizontalFlip[j * 3 * camWidth + 3 * (camWidth - 1) - i + 1] = pixels[j * 3 * camWidth + i + 1];
				horizontalFlip[j * 3 * camWidth + 3 * (camWidth - 1) - i + 2] = pixels[j * 3 * camWidth + i + 2];
			}
		}
		videoTexture90.loadData(videoRot90, camHeight, camWidth, GL_RGB);
		videoTexture180.loadData(videoRot180, camWidth, camHeight, GL_RGB);
		videoTexture270.loadData(videoRot270, camHeight, camWidth, GL_RGB);
		verticalFlipTexture.loadData(verticalFlip, camWidth, camHeight, GL_RGB);
		horizontalFlipTexture.loadData(horizontalFlip, camWidth, camHeight, GL_RGB);
	}
}

//--------------------------------------------------------------
void testApp::draw(){
	ofSetHexColor(0xffffff);
	vidGrabber.draw(20,20);
	videoTexture90.draw(40+camWidth,20, camHeight, camWidth);
	videoTexture180.draw(20, 40 + camWidth, camWidth, camHeight);
	videoTexture270.draw(40+ camWidth,40 + camWidth, camHeight, camWidth);
	verticalFlipTexture.draw(60 + camWidth + camHeight, 20, camWidth, camHeight);
	horizontalFlipTexture.draw(60+ camWidth + camHeight, 40 + camWidth, camWidth, camHeight);
}

Avec dans le .h

	ofVideoGrabber 		vidGrabber;
	unsigned char * 	videoRot90;
	unsigned char * 	videoRot180;
	unsigned char * 	videoRot270;
	unsigned char * 	verticalFlip;
	unsigned char * 	horizontalFlip;
	ofTexture			videoTexture90;
	ofTexture			videoTexture180;
	ofTexture			videoTexture270;
	ofTexture			verticalFlipTexture;
	ofTexture			horizontalFlipTexture;
	int 				camWidth;
	int 				camHeight;

En espérant qu'il te soit utile.

Dernière modification par Mushussu (2014-07-25 17:52:32)

Hors ligne

 

#3 2014-07-25 22:06:02 Re : ofTexture to ofImage

nononononono
membre
Lieu: Toulouse
Date d'inscription: 2011-02-04
Messages: 601

Re: ofTexture to ofImage



yop,
Normalement on se debrouille pour le faire avant d'allouer la texture car la communication CPU-GPU marche bien dans un sens et dans l'autre bof bof bof.... Du coup je te déconseille de lire toute ta texture.
Bref, pour lire un pixel dans une texture:
afficher la dite texture dans le viewport, puis lire le viewport : (fonction openGL)
float  pixel[4];
    glReadPixels(coordX, coordY, 1, 1, GL_RGBA, GL_FLOAT, &pixel[0]);

puis après c'est selon tes envies tu efface ta texture tu te dem...rde tu met un carré noir puis glClear GL_DEPTH tu réaffiche la scène enfin moi c'est comme ça que je fait.
++

Hors ligne

 

fil rss de cette discussion : rss

Pied de page des forums

Powered by FluxBB

codelab, graphisme & code : emoc / 2008-2017