image.cc

蒙特卡洛仿真源代码很有参考价值要按照步骤进行操作

				delete [] gerr;
				delete [] berr;
				delete [] nrerr;
				delete [] ngerr;
				delete [] nberr;
#endif // ORDEREDPSUEDO

				break;
			}

			/*
			   case StaticGray:
			   case GrayScale:
			   for (y = 0, offset = 0; y < height; y++) {
			   dithy = y & 0x3;

			   for (x = 0; x < width; x++, offset++) {
			   dithx = x & 0x3;

			   r = *(red + offset);
			   g = *(green + offset);
			   b = *(blue + offset);

			   er = r & 0x7;
			   eg = g & 0x7;
			   eb = b & 0x7;

			   if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
			   r += 8;
			   if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
			   g += 4;
			   if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
			   b += 8;

			   r = *(red_table + r);
			   g = *(green_table + g);
			   b = *(blue_table + b);

			   g = ((r * 30) + (g * 59) + (b * 11)) / 100;
			   *pixel_data++ = colors[g].pixel;
			   }

			   pixel_data = (ppixel_data += image->bytes_per_line);
			   }

			   break;
			*/

		default:
			fprintf(stderr,
			        "BImage::renderXImage: unsupported visual\n");
			delete [] d;
			XDestroyImage(image);
			return (XImage *) 0;
		}
	}
	else
	{
		switch (control->getVisual()->c_class) {
		case StaticColor:
		case PseudoColor:
			for (y = 0, offset = 0; y < height; y++)
			{
				for (x = 0; x < width; x++, offset++) {
					r = red_table[red[offset]];
					g = green_table[green[offset]];
					b = blue_table[blue[offset]];

					pixel = (r * cpccpc) + (g * cpc) + b;
					*pixel_data++ = colors[pixel].pixel;
				}

				pixel_data = (ppixel_data += image->bytes_per_line);
			}

			break;

		case TrueColor:
			for (y = 0, offset = 0; y < height; y++)
			{
				for (x = 0; x < width; x++, offset++) {
					r = red_table[red[offset]];
					g = green_table[green[offset]];
					b = blue_table[blue[offset]];

					pixel = (r << red_offset) | (g << green_offset) | (b << blue_offset);

					switch (o) {
					case 16: // 16bpp LSB

						*pixel_data++ = pixel;
						*pixel_data++ = pixel >> 8;
						break;

					case 17: // 16bpp MSB

						*pixel_data++ = pixel >> 8;
						*pixel_data++ = pixel;
						break;

					case 24: // 24bpp LSB

						*pixel_data++ = pixel;
						*pixel_data++ = pixel >> 8;
						*pixel_data++ = pixel >> 16;
						break;

					case 25: // 24bpp MSB

						*pixel_data++ = pixel >> 16;
						*pixel_data++ = pixel >> 8;
						*pixel_data++ = pixel;
						break;

					case 32: // 32bpp LSB

						*pixel_data++ = pixel;
						*pixel_data++ = pixel >> 8;
						*pixel_data++ = pixel >> 16;
						*pixel_data++ = pixel >> 24;
						break;

					case 33: // 32bpp MSB

						*pixel_data++ = pixel >> 24;
						*pixel_data++ = pixel >> 16;
						*pixel_data++ = pixel >> 8;
						*pixel_data++ = pixel;
						break;
					}
				}

				pixel_data = (ppixel_data += image->bytes_per_line);
			}

			break;

		case StaticGray:
		case GrayScale:
			for (y = 0, offset = 0; y < height; y++)
			{
				for (x = 0; x < width; x++, offset++) {
					r = *(red_table + *(red + offset));
					g = *(green_table + *(green + offset));
					b = *(blue_table + *(blue + offset));

					g = ((r * 30) + (g * 59) + (b * 11)) / 100;
					*pixel_data++ = colors[g].pixel;
				}

				pixel_data = (ppixel_data += image->bytes_per_line);
			}

			break;

		default:
			fprintf(stderr,
			        "BImage::renderXImage: unsupported visual\n");
			delete [] d;
			XDestroyImage(image);
			return (XImage *) 0;
		}
	}

	image->data = (char *) d;
	return image;
}


Pixmap BImage::renderPixmap(void) {
	Pixmap pixmap =
	    XCreatePixmap(control->getBaseDisplay()->getXDisplay(),
	                  control->getDrawable(), width, height, control->getDepth());

	if (pixmap == None) {
		fprintf(stderr,
		        "BImage::renderPixmap: error creating pixmap\n");
		return None;
	}

	XImage *image = renderXImage();

	if (! image) {
		XFreePixmap(control->getBaseDisplay()->getXDisplay(), pixmap);
		return None;
	} else if (! image->data) {
		XDestroyImage(image);
		XFreePixmap(control->getBaseDisplay()->getXDisplay(), pixmap);
		return None;
	}

	XPutImage(control->getBaseDisplay()->getXDisplay(), pixmap,
	          DefaultGC(control->getBaseDisplay()->getXDisplay(),
	                    control->getScreenInfo()->getScreenNumber()),
	          image, 0, 0, 0, 0, width, height);

	if (image->data) {
		delete [] image->data;
		image->data = NULL;
	}

	XDestroyImage(image);

	return pixmap;
}


void BImage::bevel1(void) {
	if (width > 2 && height > 2) {
		unsigned char *pr = red, *pg = green, *pb = blue;

		register unsigned char r, g, b, rr ,gg ,bb;
		register unsigned int w = width, h = height - 1, wh = w * h;

		while (--w) {
			r = *pr;
			rr = r + (r >> 1);
			if (rr < r) rr = ~0;
			g = *pg;
			gg = g + (g >> 1);
			if (gg < g) gg = ~0;
			b = *pb;
			bb = b + (b >> 1);
			if (bb < b) bb = ~0;

			*pr = rr;
			*pg = gg;
			*pb = bb;

			r = *(pr + wh);
			rr = (r >> 2) + (r >> 1);
			if (rr > r) rr = 0;
			g = *(pg + wh);
			gg = (g >> 2) + (g >> 1);
			if (gg > g) gg = 0;
			b = *(pb + wh);
			bb = (b >> 2) + (b >> 1);
			if (bb > b) bb = 0;

			*((pr++) + wh) = rr;
			*((pg++) + wh) = gg;
			*((pb++) + wh) = bb;
		}

		r = *pr;
		rr = r + (r >> 1);
		if (rr < r) rr = ~0;
		g = *pg;
		gg = g + (g >> 1);
		if (gg < g) gg = ~0;
		b = *pb;
		bb = b + (b >> 1);
		if (bb < b) bb = ~0;

		*pr = rr;
		*pg = gg;
		*pb = bb;

		r = *(pr + wh);
		rr = (r >> 2) + (r >> 1);
		if (rr > r) rr = 0;
		g = *(pg + wh);
		gg = (g >> 2) + (g >> 1);
		if (gg > g) gg = 0;
		b = *(pb + wh);
		bb = (b >> 2) + (b >> 1);
		if (bb > b) bb = 0;

		*(pr + wh) = rr;
		*(pg + wh) = gg;
		*(pb + wh) = bb;

		pr = red + width;
		pg = green + width;
		pb = blue + width;

		while (--h) {
			r = *pr;
			rr = r + (r >> 1);
			if (rr < r) rr = ~0;
			g = *pg;
			gg = g + (g >> 1);
			if (gg < g) gg = ~0;
			b = *pb;
			bb = b + (b >> 1);
			if (bb < b) bb = ~0;

			*pr = rr;
			*pg = gg;
			*pb = bb;

			pr += width - 1;
			pg += width - 1;
			pb += width - 1;

			r = *pr;
			rr = (r >> 2) + (r >> 1);
			if (rr > r) rr = 0;
			g = *pg;
			gg = (g >> 2) + (g >> 1);
			if (gg > g) gg = 0;
			b = *pb;
			bb = (b >> 2) + (b >> 1);
			if (bb > b) bb = 0;

			*(pr++) = rr;
			*(pg++) = gg;
			*(pb++) = bb;
		}

		r = *pr;
		rr = r + (r >> 1);
		if (rr < r) rr = ~0;
		g = *pg;
		gg = g + (g >> 1);
		if (gg < g) gg = ~0;
		b = *pb;
		bb = b + (b >> 1);
		if (bb < b) bb = ~0;

		*pr = rr;
		*pg = gg;
		*pb = bb;

		pr += width - 1;
		pg += width - 1;
		pb += width - 1;

		r = *pr;
		rr = (r >> 2) + (r >> 1);
		if (rr > r) rr = 0;
		g = *pg;
		gg = (g >> 2) + (g >> 1);
		if (gg > g) gg = 0;
		b = *pb;
		bb = (b >> 2) + (b >> 1);
		if (bb > b) bb = 0;

		*pr = rr;
		*pg = gg;
		*pb = bb;
	}
}


void BImage::bevel2(void) {
	if (width > 4 && height > 4) {
		unsigned char r, g, b, rr ,gg ,bb, *pr = red + width + 1,
		        *pg = green + width + 1, *pb = blue + width + 1;
		unsigned int w = width - 2, h = height - 1, wh = width * (height - 3);

		while (--w) {
			r = *pr;
			rr = r + (r >> 1);
			if (rr < r) rr = ~0;
			g = *pg;
			gg = g + (g >> 1);
			if (gg < g) gg = ~0;
			b = *pb;
			bb = b + (b >> 1);
			if (bb < b) bb = ~0;

			*pr = rr;
			*pg = gg;
			*pb = bb;

			r = *(pr + wh);
			rr = (r >> 2) + (r >> 1);
			if (rr > r) rr = 0;
			g = *(pg + wh);
			gg = (g >> 2) + (g >> 1);
			if (gg > g) gg = 0;
			b = *(pb + wh);
			bb = (b >> 2) + (b >> 1);
			if (bb > b) bb = 0;

			*((pr++) + wh) = rr;
			*((pg++) + wh) = gg;
			*((pb++) + wh) = bb;
		}

		pr = red + width;
		pg = green + width;
		pb = blue + width;

		while (--h) {
			r = *pr;
			rr = r + (r >> 1);
			if (rr < r) rr = ~0;
			g = *pg;
			gg = g + (g >> 1);
			if (gg < g) gg = ~0;
			b = *pb;
			bb = b + (b >> 1);
			if (bb < b) bb = ~0;

			*(++pr) = rr;
			*(++pg) = gg;
			*(++pb) = bb;

			pr += width - 3;
			pg += width - 3;
			pb += width - 3;

			r = *pr;
			rr = (r >> 2) + (r >> 1);
			if (rr > r) rr = 0;
			g = *pg;
			gg = (g >> 2) + (g >> 1);
			if (gg > g) gg = 0;
			b = *pb;
			bb = (b >> 2) + (b >> 1);
			if (bb > b) bb = 0;

			*(pr++) = rr;
			*(pg++) = gg;
			*(pb++) = bb;

			pr++;
			pg++;
			pb++;
		}
	}
}


void BImage::invert(void) {
	register unsigned int i, j, wh = (width * height) - 1;
	unsigned char tmp;

	for (i = 0, j = wh; j > i; j--, i++) {
		tmp = *(red + j);
		*(red + j) = *(red + i);
		*(red + i) = tmp;

		tmp = *(green + j);
		*(green + j) = *(green + i);
		*(green + i) = tmp;

		tmp = *(blue + j);
		*(blue + j) = *(blue + i);
		*(blue + i) = tmp;
	}
}


void BImage::dgradient(void) {
	// diagonal gradient code was written by Mike Cole <[e-mail]>
	// modified for interlacing by Brad Hughes

	float drx, dgx, dbx, dry, dgy, dby, yr = 0.0, yg = 0.0, yb = 0.0,
	        xr = (float) from->getRed(),
	             xg = (float) from->getGreen(),
	                  xb = (float) from->getBlue();
	unsigned char *pr = red, *pg = green, *pb = blue;
	unsigned int w = width * 2, h = height * 2, *xt = xtable, *yt = ytable;

	register unsigned int x, y;

	dry = drx = (float) (to->getRed() - from->getRed());
	dgy = dgx = (float) (to->getGreen() - from->getGreen());
	dby = dbx = (float) (to->getBlue() - from->getBlue());

	// Create X table
	drx /= w;
	dgx /= w;
	dbx /= w;

	for (x = 0; x < width; x++) {
		*(xt++) = (unsigned char) (xr);
		*(xt++) = (unsigned char) (xg);
		*(xt++) = (unsigned char) (xb);

		xr += drx;
		xg += dgx;
		xb += dbx;
	}

	// Create Y table
	dry /= h;
	dgy /= h;
	dby /= h;

	for (y = 0; y < height; y++) {
		*(yt++) = ((unsigned char) yr);
		*(yt++) = ((unsigned char) yg);
		*(yt++) = ((unsigned char) yb);

		yr += dry;
		yg += dgy;
		yb += dby;
	}

	// Combine tables to create gradient

#ifdef    INTERLACE
	if (! interlaced) {
#endif // INTERLACE

		// normal dgradient
		for (yt = ytable, y = 0; y < height; y++, yt += 3) {
			for (xt = xtable, x = 0; x < width; x++) {
				*(pr++) = *(xt++) + *(yt);
				*(pg++) = *(xt++) + *(yt + 1);
				*(pb++) = *(xt++) + *(yt + 2);
			}
		}