C++ ofImage::update方法代码示例

 void update() {
     cam->update();
     if(cam->isFrameNew()) {
         ofPixels& pix = cam->getPixels();
         int skip = 2;
         int range = mouseX / 25;
         for(int y = 0; y < pix.getHeight(); y += skip) {
             for(int x = 0; x < pix.getWidth(); x += skip) {
                 ofColor cur = pix.getColor(x, y);
                 ofColor result(0, 0, 0, 0);
                 if(cur.r < range || cur.r > 255-range) {
                     result.r = 255;
                     result.a = 255;
                 }
                 if(cur.g < range || cur.g > 255-range) {
                     result.g = 255;
                     result.a = 255;
                 }
                 if(cur.b < range || cur.b > 255-range) {
                     result.b = 255;
                     result.a = 255;
                 }
                 clipping.setColor(x, y, result);
             }
         }
         clipping.update();
         
         if(recording) {
             string fn = "images/" + ofToString(frameCount, 6, '0') + ".jpg";
             imageSaver.saveImage(pix, fn);
             frameCount++;
         }
     }
 }

	void makeTransparent(ofImage &img) {
		img.setImageType(OF_IMAGE_COLOR_ALPHA); //make sure it can have alphas
		for(int i = 3; i < img.height*img.width*4; i+=4){
			if(img.getPixels()[i-1]==0) { //if blue is 0 make pixel transparent
				img.getPixels()[i]=0;
			}
		}
		img.update();
	}

//--------------------------------------------------------------
// create a visual representation of the simulation
void Rd::getImage(ofImage & image, const ofColor & c1, const ofColor & c2){
	unsigned char * pixels = image.getPixels();
	for(int indexImg = 0, indexA = 0; indexA < A.size(); indexImg += 3, indexA++){
		ofColor c = c1.getLerped(c2, A[indexA] * A[indexA]);
		pixels[indexImg] = c.r;
		pixels[indexImg + 1] = c.b;
		pixels[indexImg + 2] = c.g;
	}
	image.update();
}

void ofApp::update() {
	step();
	
	unsigned char* pixels = buffer.getPixels();
	int n = num * num;
  for (int i = 0; i < n; i++) {
		pixels[i] = 128 + 100*grid[i];
  }	
	buffer.update();
}

	void convert(ofxCvGrayscaleImage &src, ofImage &dst) {
		for(int i = 0; i < src.height*src.width; i += 1) {
			if(src.getPixels()[i]==0) {
				dst.getPixels()[i*4] = 0;
			} else {
				dst.getPixels()[i*4] = 0xffffffff;
			}
		}
		dst.update();
	}

void testApp::normalizeImage(ofImage& img, ofImage& normalized) {
	srcTracker.update(toCv(img));
	if(srcTracker.getFound()) {
		drawNormalized(srcTracker, img, srcNormalized);
		normalized.allocate(normalizedWidth, normalizedHeight, OF_IMAGE_COLOR);
		srcNormalized.readToPixels(normalized.getPixelsRef());
		normalized.update();
	} else {
		ofLogWarning() << "couldn't find the face" << endl;
	}
}

//--------------------------------------------------------------
void testApp::update(){
	unsigned char * pixels = img2.getPixels();
	for(int x = 0;x<600;++x){
		for(int y=0;y<200;++y){
			char brightess = ofMap(ofNoise(x*faktor,y*faktor,ofGetFrameNum()*faktor),0,1,0,255);
			pixels[y*600+x] = brightess;
		}
	}

	unsigned char * rgbPixels = img3.getPixels();
	for(int x = 0;x<600;++x){
		for(int y=0;y<200;++y){
			for(int c=0;c<3;++c){
				rgbPixels[(y*600+x)*3+c] = ofMap(ofNoise(x*faktor,y*faktor,c,ofGetFrameNum()*faktor),0,1,0,255);
			}
		}
	}

	img2.update();
	img3.update();
}

void ofxDepthImageCompressor::convertTo8BitImage(unsigned short* buf, ofImage& image){
	int nearPlane = 500;
	int farPlane = 7000;
	unsigned char* pix = image.getPixels();
    int stride = image.getPixelsRef().getNumChannels();
	for(int i = 0; i < 640*480; i++){
        //ofMap(buf[i], nearPlane, farPlane, 255, 0, true);
        unsigned char value = buf[i] == 0 ? 0 : 255 - (255 * (buf[i] - nearPlane) ) / farPlane;// + ofMap(buf[i], nearPlane, farPlane, 255, 0, true);
        for(int c = 0; c < stride; c++){
            pix[i*stride+c] = value;
        }
	}
	image.update();
}

    void update(){
        grayImg = colorImg;
        grayImg.threshold( ofMap(ofGetMouseX(), 0, 900, 0, 255) );

        Canny(grayImg, cannyImg, 120, 120, 3);
        
        thin(cannyImg);
        
        cannyImg.update();


        cannyInvertImg = cannyImg;
        invert(cannyInvertImg);
        
    }

//--------------------------------------------------------------
void testApp::setup(){
	ofSetFrameRate(60);

	img.allocate(600,200,OF_IMAGE_GRAYSCALE);
	img2.allocate(600,200,OF_IMAGE_GRAYSCALE);
	img3.allocate(600,200,OF_IMAGE_COLOR);

	unsigned char * pixels = img.getPixels();
	for(int x = 0;x<600;++x){
		for(int y=0;y<200;++y){
			char brightess = ofMap(ofNoise(x*faktor,y*faktor),0,1,0,255);
			pixels[y*600+x] = brightess;
		}
	}
	img.update();
}

void ofxBaseGui::loadStencilFromHex(ofImage& img, unsigned char* data) {
	int width = img.getWidth();
	int height = img.getHeight();
	int i = 0;
	ofColor on(255, 255);
	ofColor off(255, 0);
	for(int y = 0; y < height; y++) {
		for(int x = 0; x < width; x++) {
			int shift = i % 8;
			int offset = i / 8;
			bool cur = (data[offset] >> shift) & 1;
			img.setColor(x, y, cur ? on : off);
			i++;
		}
	}
	img.update();
}

void captureApp::generateSpotlight(ofImage& img) {
	int diffusion = 100;
	img.setImageType(OF_IMAGE_GRAYSCALE);
	unsigned char* pixels = img.getPixels();
	int w = img.getWidth();
	int h = img.getHeight();
	float maxDistance = (w < h ? w : h) / 2;
	for(int y = 0; y < h; y++) {
		for(int x = 0; x < w; x++) {
			int i = y * w + x;
			int xrand = ofRandom(-diffusion, diffusion);
			int yrand = ofRandom(-diffusion, diffusion);
			pixels[i] = pow(ofMap(ofDist(w / 2, h / 2, x + xrand, y + yrand), 0, maxDistance, 1, 0, true), 4) * 255;
		}
	}	
	img.update();
}

	void synthImage()
	{
		const int num_pixels = w * h;
		unsigned char *synth_pixels = synth.getPixels();
		unsigned char *img1_pixels = img1.getPixels();
		
		// amount
		for (int i=0; i<num_pixels; i++)
			avarage_pixel_value += img1_pixels[i];
		
		// calc avarage
		avarage_pixel_value /= num_pixels;
		
		// set to synth image
		for (int i=0; i<num_pixels; i++)
			synth_pixels[i] = avarage_pixel_value;
		
		// update texture
		synth.update();
	}

void faceColorToTexture(ofMesh& mesh, ofImage& image)
{
	vector<ofFloatColor> &color = mesh.getColors();
	int num_face = color.size() / 3;
	
	int tex_size = ofNextPow2(ceil(sqrt(num_face)));
	
	bool arb = ofGetUsingArbTex();
	ofDisableArbTex();
	image.allocate(tex_size, tex_size, OF_IMAGE_COLOR);
	if (arb) ofEnableArbTex();
	
	mesh.clearTexCoords();
	
	image.getPixelsRef().set(0);
	
	float texel_size = (1. / image.getWidth()) * 0.5;
	
	for (int i = 0; i < num_face; i++)
	{
		int u = (i % tex_size);
		int v = (i / tex_size);
		
		ofColor c = color[i * 3];
		
		image.setColor(u, v, c);
		
		float uu = (float)u / image.getWidth() + texel_size;
		float vv = (float)v / image.getHeight() + texel_size;
		
		mesh.addTexCoord(ofVec2f(uu, vv));
		mesh.addTexCoord(ofVec2f(uu, vv));
		mesh.addTexCoord(ofVec2f(uu, vv));
	}
	
	image.update();
	mesh.clearColors();
}