C++ Image32类代码示例

int Image32::FunFilter(Image32& outputImage) const
{
	double height = this->height();
	double width = this->width();

	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
				double y1 =  (double) y /  (double) (height-1.0);
				double x1 = (double) x / (double) (width-1.0);
				double r = sqrt( pow(x1 - 0.5, 2.0) + pow(y1 - 0.5, 2.0) );

				double a = atan2((y1 - 0.5) , (x1 - 0.5));
				
				double rd = pow(r, 2.5)/.5;

				float xNew = ((rd*cos(a)) + 0.5) * (width-1);
				float yNew = ((rd*sin(a)) + 0.5) * (height-1);

				Pixel32 pix = this->NearestSample(xNew,yNew);

				outputImage.pixel(x,y).r = pix.r;
				outputImage.pixel(x,y).g = pix.g;
				outputImage.pixel(x,y).b = pix.b;
		}
	}

	return 1;
}

/*
 *	scales each pixel's rgb by the brightness factor to increase brightness
 */
int Image32::Brighten(const float& brightness,Image32& outputImage) const
{
	int r1, g1, b1;
    for (int x = 0; x < outputImage.width(); x++)
		for (int y = 0; y < outputImage.height(); y++)
		{	
			// clamp [0,255]
			r1 = (int)(pixel(x,y).r*brightness);
			if (r1 > 255)
				r1 = 255;
			if (r1 < 0)
				r1 = 0;
			g1 = (int)(pixel(x,y).g*brightness);
			if (g1 > 255)
				g1 = 255;
			if (g1 < 0)
				g1 = 0;
			b1 = (int)(pixel(x,y).b*brightness);
			if (b1 > 255)
				b1 = 255;
			if (b1 < 0)
				b1 = 0;

			// write clamped values to outputImage
			outputImage.pixel(x,y).r = r1;
			outputImage.pixel(x,y).g = g1;
			outputImage.pixel(x,y).b = b1;
		}
    return 1;
}

int Image32::Brighten(const float& brightness,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	outputImage.setSize(width, height);

	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			int r = this->pixel(x,y).r;
			int g = this->pixel(x,y).g;
			int b = this->pixel(x,y).b;
			int rBright = int(r * brightness);
			int gBright = int(g * brightness);
			int bBright = int(b * brightness);
			if(rBright <= 255 && gBright <= 255 && bBright <= 255 ){
				outputImage.pixel(x,y).r = rBright;
				outputImage.pixel(x,y).g = gBright;
				outputImage.pixel(x,y).b = bBright;
				outputImage.pixel(x,y).a = this->pixel(x,y).a;
			}
			else{
				// must clamp if any r,g,b values are over 255
				int maxBrightness = 255 / max(r,max(g,b));
				outputImage.pixel(x,y).r = int(r * maxBrightness);
				outputImage.pixel(x,y).g = int(g * maxBrightness);
				outputImage.pixel(x,y).b = int(b * maxBrightness);
				outputImage.pixel(x,y).a = this->pixel(x,y).a;
			}
		}
	}
	return 1;
}

int Image32::BeierNeelyMorph(const Image32& source,const Image32& destination,const OrientedLineSegmentPairs& olsp,const float& timeStep,Image32& outputImage) {
    OrientedLineSegmentPairs olsp1,olsp2;
    OrientedLineSegment ols;
    Image32 temp1,temp2;
    int i;

    // Generate the in-between line segment pairs
    if(!olsp1.setCount(olsp.count) || !olsp2.setCount(olsp.count)) {
        return 0;
    }
    for(i=0; i<olsp.count; i++) {
        olsp1.segments1[i]=olsp.segments1[i];
        olsp2.segments1[i]=olsp.segments2[i];
        OrientedLineSegment::Blend(olsp.segments1[i],olsp.segments2[i],timeStep,ols);
        olsp1.segments2[i]=ols;
        olsp2.segments2[i]=ols;
    }

    // Generate the in-between morphs
    if(!source.Warp(olsp1,temp1) || !destination.Warp(olsp2,temp2)) {
        return 0;
    }

    // Cross-dissolve to get the final image
    return CrossDissolve(temp1,temp2,timeStep,outputImage);
}

int Image32::Warp(const OrientedLineSegmentPairs& olsp,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	outputImage.setSize(width,height);

	int numOfLineSegments = olsp.count;

	float dSumX, dSumY, weight, weightSum;
	cout << "warp" << "\n";
	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			for(int i=0; i<numOfLineSegments; ++i){
				dSumX = 0, dSumY = 0, weightSum = 0;
				weight = olsp.segments2[i].getWeight(x,y);
				weightSum += weight;

				float sourceX, sourceY;

				olsp.segments1[i].GetSourcePosition(olsp.segments1[i], olsp.segments2[i], x, y, sourceX, sourceY);

				dSumX += (sourceX - x) * weight;
				dSumY += (sourceY - y) * weight;
			}
			
			 
			outputImage.pixel(x,y).r = this->pixel(x + (dSumX/weightSum), y + (dSumY/weightSum)).r;
			outputImage.pixel(x,y).g = this->pixel(x + (dSumX/weightSum), y + (dSumY/weightSum)).g;
			outputImage.pixel(x,y).b = this->pixel(x + (dSumX/weightSum), y + (dSumY/weightSum)).b;
		}
	}
	return 1;
}

/** This function is called when the user presses a key. */
void RayWindow::KeyboardFunction( unsigned char c, int x, int y ){
	char temp[500];
	Image32 img;
	int z;
	switch( c ){
		case KEY_ESCAPE:
			exit( 0 );
			break;		
		case 'I':
			printf("Image Name: ");
			fgets(temp,500,stdin);     // gets(temp);
			TakeSnapshot(img);
			z = img.WriteImage(temp);
			printf("Wrote to file: %s\n, %i",temp, z);
			break;
		case 'p':
			fprintf(stderr,"\nPos: (%g,%g,%g)\n Dir: (%g,%g,%g)\n Up: (%g,%g,%g)\n",
				scene->camera->position[0],scene->camera->position[1],scene->camera->position[2],
				scene->camera->direction[0],scene->camera->direction[1],scene->camera->direction[2],
				scene->camera->up[0],scene->camera->up[1],scene->camera->up[2]);
			break;


	}
}

int Image32::Contrast(const float& contrast,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	outputImage.setSize(width, height);

	float totalLum = 0.0;
	int numPixels = 0;

	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			int r = this->pixel(x,y).r;
			int g = this->pixel(x,y).g;
			int b = this->pixel(x,y).b;
			float l = 0.30*r + 0.59*g + 0.11*b;
			totalLum += l;
			numPixels += 1;
		}
	}	
	float meanLum = totalLum / numPixels;

	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			int r = this->pixel(x,y).r;
			int g = this->pixel(x,y).g;
			int b = this->pixel(x,y).b;
			int a = this->pixel(x,y).a;

			float l = 0.30*r + 0.59*g + 0.11*b;
			float lDiff = l - meanLum;

			float maxContrast;
			if(lDiff >= 0){ 
				maxContrast = (255 - (max(r,max(g,b)) - lDiff)) / lDiff;
			}
			else{
				maxContrast = fabs(((min(r,min(g,b))) - lDiff) / lDiff); // lDiff is negative, so adding to minimum of r,g,b
			} 

			float contrastClamped = min(maxContrast,contrast);

			outputImage.pixel(x,y).r = contrastClamped*lDiff + (r-lDiff);
			outputImage.pixel(x,y).g = contrastClamped*lDiff + (g-lDiff);
			outputImage.pixel(x,y).b = contrastClamped*lDiff + (b-lDiff);
			outputImage.pixel(x,y).a = a;
		}
	}	
	return 1;
}

/** This function reads the current frame buffer and sets the pixels of the image accordingly. */
int RayWindow::TakeSnapshot(Image32& img){
	GLfloat *pixels;
	int i,j,temp;
	Pixel p;
	GLint vp[4];
	glGetIntegerv(GL_VIEWPORT,vp);

	if(!img.setSize(vp[2],vp[3])){return 0;}
	pixels=new GLfloat[vp[2]*vp[3]*3];
	if(!pixels){return 0;}
	glReadBuffer(GL_FRONT);
	glReadPixels(vp[0],vp[1],vp[2],vp[3],GL_RGB,GL_FLOAT,pixels);

	for(i=0;i<vp[3];i++){
		for(j=0;j<vp[2];j++){
			temp=0+j*3+(vp[3]-i-1)*(vp[2])*3;
			p.r=255*pixels[temp];
			temp=1+j*3+(vp[3]-i-1)*(vp[2])*3;
			p.g=255*pixels[temp];
			temp=2+j*3+(vp[3]-i-1)*(vp[2])*3;
			p.b=255*pixels[temp];
			img(j,i)=p;
		}
	}
	delete[] pixels;
	return 1;
}

int Image32::OrderedDither2X2(const int& bits,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	int i;
	int j;
	float D[2][2];
	D[0][0] = 1.0;
	D[0][1] = 3.0;
	D[1][0] = 4.0;
	D[1][1] = 2.0;

	Image32 interImage;
	interImage.setSize(width,height);

	float scaler255 = (255.0/pow(2,bits-1));

	this->Quantize(bits,interImage);


	for(int y=0; y<height; ++y){
		for (int x = 0; x<width; ++x){
			i = x % 2;
			j = y % 2;

			float r = float(this->pixel(x,y).r) / 255.0;
			float g = float(this->pixel(x,y).g) / 255.0;
			float b = float(this->pixel(x,y).b) / 255.0;

			float cR = r*pow(2,bits-1);
			float cG = g*pow(2,bits-1);
			float cB = b*pow(2,bits-1);

			float eR =  cR - floor(cR);
			float eG =  cG - floor(cG);
			float eB =  cB - floor(cB);

			if(eR > (D[i][j] / 8)) {outputImage.pixel(x,y).r = int(ceil(cR)*scaler255);}
			else{outputImage.pixel(x,y).r = int(floor(cR) * scaler255);}

			if(eG > (D[i][j] / 8)) {outputImage.pixel(x,y).g = int(ceil(cG)*scaler255);}
			else{outputImage.pixel(x,y).g = int(floor(cG) * scaler255);}

			if(eB > (D[i][j] / 8)) {outputImage.pixel(x,y).b = int(ceil(cB)*scaler255);}
			else{outputImage.pixel(x,y).b = int(floor(cB) * scaler255);}

			outputImage.pixel(x,y).a = this->pixel(x,y).a;
		}
	}
	return 1;
}

void Win32CompatibleBitmap::Set(Image32 &image)
{
///!!! надо сделать по нормальному, а не через SetPixel !!!
	clear();
	int w = image.width();
	int h = image.height();
	if (w<=0 && h<=0) return;
	
	init(w, h);
	if (!handle) return;
	
	HDC dc = CreateCompatibleDC(0);

	if (!dc) return;

	_w = w;
	_h = h;

	HGDIOBJ old = ::SelectObject(dc, handle);

	int i;
	bool masked = false;
		
	for (int y = 0; y<h; y++) {
		unsigned32 *t = image.line(y);
		char *m = (masked) ? mask.ptr()+y*w : 0;
		for (i=0; i<w; i++) {
			if (t[i] > 0x80000000)
			{
				if (!masked) {
					mask.alloc(w*h);
					memset(mask.ptr(), 1, w*h);
					masked = true;
					m = mask.ptr()+y*w;
				}
				m[i] = 0;
			}
			::SetPixel(dc, i, y, t[i]&0xFFFFFF);
		}
	}

	::SelectObject(dc, old);
	DeleteDC(dc);
}

int main(int argc,char *argv[])
{
	if(argc < 6)
	{
		std::cerr<<"Usage: render XMLfile w s e n [OSMfile]" << std::endl;
		exit(0);
	}

	datasource_cache::instance()->register_datasources
		("/usr/local/lib/mapnik/input");
	freetype_engine::register_font
		("/usr/local/lib/mapnik/fonts/DejaVuSans.ttf");

	Map m (800,800);
	load_map(m,argv[1]);
	
	if(argc>6)
	{
		parameters p;
		p["type"] = "osm";
		p["file"] = argv[6];
		for(int count=0; count<m.layerCount(); count++)
		{
			parameters q = m.getLayer(count).datasource()->params();
			m.getLayer(count).set_datasource(datasource_cache::instance()->
				create(p));
		}
	}

	Envelope<double> bbox (atof(argv[2]),atof(argv[3]),
							atof(argv[4]),atof(argv[5]));
										
	m.zoomToBox(bbox);

	Image32 buf (m.getWidth(), m.getHeight());
	agg_renderer<Image32> r(m,buf);
	r.apply();

	save_to_file<ImageData32>(buf.data(),"blah.png","png");

	return 0;
}

int Image32::AddRandomNoise(const float& noise,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	outputImage.setSize(width, height);
	int noiseRange = (noise * 256) * 2;
	
	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			int randNum;
			if(noiseRange != 0) randNum = (rand() % noiseRange) - (.5*noiseRange);
			else{ randNum = 0; }
			outputImage.pixel(x,y).r = max(0,min(255,randNum + this->pixel(x,y).r));
			outputImage.pixel(x,y).g = max(0,min(255,randNum + this->pixel(x,y).g));
			outputImage.pixel(x,y).b = max(0,min(255,randNum + this->pixel(x,y).b));
			outputImage.pixel(x,y).a = this->pixel(x,y).a;
		}	
	}
	return 1;	
}

int Image32::Saturate(const float& saturation,Image32& outputImage) const
{
	int height = this->height();
	int width = this->width();
	outputImage.setSize(width, height);

	for(int y=0; y<height; ++y){
		for(int x=0; x<width; ++x){
			int r = this->pixel(x,y).r;
			int g = this->pixel(x,y).g;
			int b = this->pixel(x,y).b;

			float l = 0.30*r + 0.59*g + 0.11*b;

			float rDiff = r-l;
			float gDiff = g-l;
			float bDiff = b-l;

			bool rOverflow = (r-rDiff) + rDiff*saturation > 255 || (r-rDiff) + rDiff*saturation < 0;
			bool gOverflow = (g-gDiff) + gDiff*saturation > 255 || (g-gDiff) + gDiff*saturation < 0;
			bool bOverflow = (b-bDiff) + bDiff*saturation > 255 || (b-bDiff) + bDiff*saturation < 0;

			float satClamped = saturation; // if no overflows, satClamped is saturation
			if(rOverflow){ // if r overflows, clamp sat to max so r doesn't overflow
				satClamped = min((r-rDiff), 255-(r-rDiff)) / rDiff;
			}
			if(gOverflow){ // if g overflows, clamp sat to max so g doesn't overflow (or satClamped if less)
				satClamped = min(min((g-gDiff), 255-(g-gDiff)) / gDiff, satClamped);
			}
			if(bOverflow){ // if b overflows, clamp sat to max so b doesn't overflow (or satClamped if less)
				satClamped = min(min((b-bDiff), 255-(b-bDiff)) / bDiff, satClamped);
			}
			outputImage.pixel(x,y).r = satClamped*rDiff + (r-rDiff);
			outputImage.pixel(x,y).g = satClamped*gDiff + (g-gDiff);
			outputImage.pixel(x,y).b = satClamped*bDiff + (b-bDiff);
			outputImage.pixel(x,y).a = this->pixel(x,y).a;
		}
	}	
	return 1;
}

    void image_symbolizer::render(Feature const& feat,CoordTransform const& t,Image32& image) const	
    {
	geometry_ptr const& geom=feat.get_geometry();
	if (geom)
	{
	    double x;
	    double y;
	    geom->label_position(&x,&y);
	    t.forward_x(&x);
	    t.forward_y(&y);
	    int w=symbol_.width();
	    int h=symbol_.height();    
	    int px=int(ceil(x - 0.5 * w));
	    int py=int(ceil(y - 0.5 * h));
	    image.set_rectangle_alpha(px,py,symbol_);
	}
    }

int RayScene::RayTrace(const int& width,const int& height,const int& rLimit,const double& cLimit,Image32& img){
	int i,j;
	Ray3D ray;
	Point3D c;
	Pixel32 p;
	int rayCount=0;

	if(!img.setSize(width,height)){return 0;}
	ray.position=camera->position;
	for(i=0;i<width;i++){
		printf("           \r");
		printf("%3.1f\r",(float)i/width*100);
		for(j=0;j<height;j++){
			ray=GetRay(camera,i,height-j-1,width,height);
			c=GetColor(ray,rLimit,Point3D(cLimit,cLimit,cLimit));
			p.r=(int)(c[0]*255);
			p.g=(int)(c[1]*255);
			p.b=(int)(c[2]*255);
			img(i,j)=p;
		}
	}
	return 1;
}