public void Image_GetSetPixel() { Image i = new Image(1, 1); Color c = i.GetPixel(0, 0); Assert.AreEqual(c.ToString(), "rgba(0,0,0,0.0)"); i.SetPixel(0,0, new Color(255, 255, 255)); Color c1 = i.GetPixel(0, 0); Assert.AreEqual(c1.ToString(), "rgb(255,255,255)"); }
public void ImageView_IsSolid() { Image i = new Image(256, 256); ImageView iv = i.View(0, 0, 256, 256); Assert.IsTrue(iv.IsSolid()); i.SetPixel(0, 0, new Color("red")); iv = i.View(0, 0, 256, 256); Assert.IsFalse(iv.IsSolid()); }
public override Image Load(Stream s) { Tiff tif = Tiff.Open(s); FieldValue[] value = tif.GetField(TiffTag.ImageWidth); int width = value[0].ToInt(); value = tif.GetField(TiffTag.ImageLength); int height = value[0].ToInt(); int[] raster = new int[height * width]; tif.ReadRGBAImage(width, height, raster); Image i = new Image(width, height); int rgba, rasterOffset; byte r, g, b, a; for (uint y = 0; y < i.Height; y++) { rasterOffset = (int)(y * i.Width); for (uint x = 0; x < i.Width; x++) { rgba = raster[rasterOffset++]; r = (byte)(rgba & 0xff); g = (byte)((rgba >> 8) & 0xff); b = (byte)((rgba >> 16) & 0xff); a = (byte)((rgba >> 24) & 0xff); i.SetPixel(x, y, new Pixel(r, g, b, a)); } } // Need to flip the image. Image i2 = new Image(width, height); uint y2 = 0; for (uint y = (uint)(i.Height - 1); y >= 0 && y < i.Height; y--) { for (uint x = 0; x < i.Width; x++) { i2.SetPixel(x, y2, i.GetPixel(x, y)); } y2++; } i.Dispose(); return i2; }
void CreateBlankTexture() { LogFile.GetInstance().WriteLine("CreateBlankTexture()"); //Bitmap bitmap = new Bitmap(1, 1, System.Drawing.Imaging.PixelFormat.Format24bppRgb); //Graphics g = Graphics.FromImage(bitmap); //Pen pen = new Pen(System.Drawing.Color.FromArgb(255,255, 255, 255)); //g.DrawRectangle(pen, 0, 0, 1, 1); //DevIL.DevIL.SaveBitmap("testout.JPG", bitmap); Image image = new Image(1, 1); image.SetPixel(0, 0, 255, 255, 255, 255); this.texture = new GlTexture(image,false); }
public override Image Load(System.IO.Stream s) { if (s.ReadByte() == 255) { byte[] buf = new byte[s.Length - 1]; s.Read(buf, 0, buf.Length); s = new MemoryStream(Orvid.Compression.LZMA.Decompress(buf)); } else { s.Position = 0; } byte[] tmp = new byte[8]; s.Read(tmp, 0, 8); // skip the 8 empty bytes at the start of the file. tmp = new byte[4]; s.Read(tmp, 0, 4); uint Height = ReadUInt32(tmp); // Read the Height. s.Read(tmp, 0, 4); uint Width = ReadUInt32(tmp); // Read the Width. Image i = new Image((int)Width, (int)Height); byte r, g, b, a; for (uint x = 0; x < Width; x++) { for (uint y = 0; y < Height; y++) { r = (byte)s.ReadByte(); g = (byte)s.ReadByte(); b = (byte)s.ReadByte(); a = (byte)s.ReadByte(); i.SetPixel(x, y, new Pixel(r, g, b, a)); } } return i; }
//private class pcx_t //{ // public char manufacturer; // public char version; // public char encoding; // public char bits_per_pixel; // public short xmin, ymin, xmax, ymax; // public short hres, vres; // public int[] palette = new int[48]; // public char reserved; // public char color_planes; // public short bytes_per_line; // public short palette_type; // public byte[] filler = new byte[58]; // public byte[] data; // public pcx_t(byte[] raw) // { // manufacturer = (char)raw[0]; // version = (char)raw[1]; // encoding = (char)raw[2]; // bits_per_pixel = (char)raw[3]; // xmin = (short)((raw[4] + (raw[5] << 8)) & 0xff); // ymin = (short)((raw[6] + (raw[7] << 8)) & 0xff); // xmax = (short)((raw[8] + (raw[9] << 8)) & 0xff); // ymax = (short)((raw[10] + (raw[11] << 8)) & 0xff); // hres = (short)((raw[12] + (raw[13] << 8)) & 0xff); // vres = (short)((raw[14] + (raw[15] << 8)) & 0xff); // for (int i = 0; i < 48; i++) // palette[i] = (raw[16 + i] & 0xff); // reserved = (char)raw[64]; // color_planes = (char)raw[65]; // bytes_per_line = (short)((raw[66] + (raw[67] << 8)) & 0xff); // palette_type = (short)((raw[68] + (raw[69] << 8)) & 0xff); // for (int i = 0; i < 58; i++) // filler[i] = raw[70 + i]; // data = new byte[raw.Length - 128]; // for (int i = 0; i < raw.Length - 128; i++) // data[i] = raw[128 + i]; // } //} //private static byte[] imageData; //private static int imageWidth, imageHeight; //public static Image Load(Stream s) //{ // int[] palette, pic, ot, pix; // int k, x, y, len = 0, dataByte, runLength; // byte[] raw; // pcx_t pcx; // raw = new byte[s.Length]; // s.Read(raw, 0, (int)s.Length); // pcx = new pcx_t(raw); // raw = pcx.data; // if (pcx.manufacturer != 0x0a || pcx.version != 5 || pcx.encoding != 1 || pcx.bits_per_pixel != 8 || pcx.xmax >= 640 || pcx.ymax >= 480) // { // throw new Exception("Bad Pcx Data!"); // } // palette = new int[768]; // for (int i = 0; i < 768; i++) // { // if ((uint)(len - 128 - 768 + i) < pcx.data.Length) // { // palette[i] = pcx.data[len - 128 - 768 + i] & 0xff; // } // } // imageWidth = pcx.xmax + 1; // imageHeight = pcx.ymax + 1; // ot = new int[(pcx.ymax + 1) * (pcx.xmax + 1)]; // pic = ot; // pix = ot; // int pixcount = 0; // int rawcount = 0; // for (y = 0; y <= pcx.ymax; y++, pixcount += pcx.xmax + 1) // { // for (x = 0; x <= pcx.xmax; ) // { // dataByte = raw[rawcount++]; // if ((dataByte & 0xC0) == 0xC0) // { // runLength = dataByte & 0x3F; // dataByte = raw[rawcount++]; // } // else // runLength = 1; // while (runLength-- > 0) // pix[pixcount + x++] = dataByte & 0xff; // } // } // Image im = new Image(imageWidth, imageHeight); // imageData = new byte[imageWidth * imageHeight * 4]; // //convert to rgb format // for (k = 0; k < (imageWidth * imageHeight); k++) // { // imageData[k * 4] = (byte)palette[pic[k] * 3]; // imageData[k * 4 + 1] = (byte)palette[pic[k] * 3 + 1]; // imageData[k * 4 + 2] = (byte)palette[pic[k] * 3 + 2]; // imageData[k * 4 + 3] = 0xff; // } // uint ndx = 0; // for (uint yloc = 0; yloc < imageHeight; yloc++) // { // for (uint xloc = 0; xloc < imageWidth; xloc++) // { // im.SetPixel(xloc, yloc, new Pixel(imageData[ndx], imageData[ndx + 1], imageData[ndx + 2], imageData[ndx + 3])); // ndx += 4; // } // } // return im; //} #endregion #region Load public static Image Load(Stream input) { PcxPalette palette = null; uint[] numArray = null; Image im; PcxHeader header = new PcxHeader(input); #region Checks if (header.id != PcxId.ZSoftPCX) { throw new FormatException("Not a PCX file."); } if (((header.version != PcxVersion.Version3_0) && (header.version != PcxVersion.Version2_8_Palette)) && ((header.version != PcxVersion.Version2_8_DefaultPalette) && (header.version != PcxVersion.Version2_5))) { throw new FormatException("Unsupported PCX version: " + header.version.ToString()); } if (((header.bitsPerPixel != 1) && (header.bitsPerPixel != 2)) && ((header.bitsPerPixel != 4) && (header.bitsPerPixel != 8))) { throw new FormatException("Unsupported PCX bits per pixel: " + header.bitsPerPixel.ToString() + " bits per pixel"); } int width = (header.xMax - header.xMin) + 1; int height = (header.yMax - header.yMin) + 1; if (((width < 0) || (height < 0)) || ((width > 0xffff) || (height > 0xffff))) { throw new FormatException("Invalid image dimensions: (" + header.xMin.ToString() + "," + header.yMin.ToString() + ")-(" + header.xMax.ToString() + "," + header.yMax.ToString() + ")"); } int num3 = (header.bytesPerLine * 8) / header.bitsPerPixel; int BitDepth = header.bitsPerPixel * header.nPlanes; if ((((BitDepth != 1) && (BitDepth != 2)) && ((BitDepth != 4) && (BitDepth != 8))) && (BitDepth != 0x18)) { throw new FormatException("Unsupported PCX bit depth: " + BitDepth.ToString()); } #endregion #region Load Palette while (true) { if (BitDepth == 1) { palette = PcxPalette.FromEgaPalette(PcxPalette.MONO_PALETTE); break; } if (BitDepth >= 8) { if (BitDepth == 8) { long position = input.Position; input.Seek(-769L, SeekOrigin.End); if (input.ReadByte() != 12) { throw new FormatException("PCX palette marker not present in file"); } palette = new PcxPalette(input, 0x100); input.Seek(position, SeekOrigin.Begin); } else { palette = new PcxPalette(0x100); } break; } switch (header.version) { case PcxVersion.Version2_5: case PcxVersion.Version2_8_DefaultPalette: if (BitDepth == 2) { numArray = PcxPalette.CGA_PALETTE; palette = PcxPalette.FromEgaPalette(numArray); } break; default: numArray = new uint[0]; palette = PcxPalette.FromColorMap(header.colorMap); break; } if (numArray == null) { numArray = PcxPalette.EGA_PALETTE; } break; } #endregion im = new Image(width, height); uint[] array = new uint[width]; for (int y = 0; y < height; y++) { PcxByteReader byteReader = (header.encoding == PcxEncoding.RunLengthEncoded) ? ((PcxByteReader)new PcxRleByteReader(input)) : ((PcxByteReader)new PcxRawByteReader(input)); PcxIndexReader indxReader = new PcxIndexReader(byteReader, header.bitsPerPixel); for (int j = 0; j < header.nPlanes; j++) { for (int m = 0; m < num3; m++) { uint num10 = indxReader.ReadIndex(); if (m < width) { array[m] |= num10 << (j * header.bitsPerPixel); } } } for (int x = 0; x < width; x++) { Pixel bgra; uint TempC = array[x]; if (BitDepth == 24) { byte r = (byte)(TempC & 0xff); byte g = (byte)((TempC >> 8) & 0xff); byte b = (byte)((TempC >> 16) & 0xff); bgra = new Pixel(r, g, b, 255); } else { bgra = palette[TempC]; } im.SetPixel((uint)x, (uint)y, bgra); } } return im; }
public void Save( string filename ) { double[,] mesh = SlopeMap.GetInstance().GetSlopeMap(); int width = mesh.GetUpperBound(0) + 1; int height = mesh.GetUpperBound(1) + 1; double maxslopetoexport = Config.GetInstance().SlopemapExportMaxSlope; Image image = new Image(width, height); //Bitmap bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb); //Graphics g = Graphics.FromImage(bitmap); // cache pencolors; List<MovementAreaConfig> movementareas = Config.GetInstance().movementareas; SortedList<double, Color> sortedcolorbymaxslope = new SortedList<double, Color>(); foreach (MovementAreaConfig movementarea in movementareas) { if (movementarea.MaxSlope >= 0) { sortedcolorbymaxslope.Add(movementarea.MaxSlope, movementarea.color); } else { sortedcolorbymaxslope.Add(double.PositiveInfinity, movementarea.color); } } for (int area = 0; area < sortedcolorbymaxslope.Count; area++) { LogFile.GetInstance().WriteLine(sortedcolorbymaxslope.Keys[area] + " " + sortedcolorbymaxslope.Values[area].ToString()); } for (int i = 0; i < width; i++) { for (int j = 0; j < height; j++) { Color colortouse = new Color(1, 1, 1); for (int area = 0; area < sortedcolorbymaxslope.Count; area++) { if (mesh[i, j] < sortedcolorbymaxslope.Keys[area]) { colortouse = sortedcolorbymaxslope.Values[area]; break; } } int valuetowrite = (int)(mesh[i, j] * 255 / maxslopetoexport); valuetowrite = Math.Max(0, valuetowrite); valuetowrite = Math.Min(255, valuetowrite); image.SetPixel(i, j, (byte)(colortouse.r * 255 * valuetowrite), (byte)( colortouse.g * 255 * valuetowrite ), (byte)( colortouse.b * 255 * valuetowrite ), 255 ); } } image.Save(filename); exportheightmapfilename = filename; MainUI.GetInstance().uiwindow.InfoMessage("Slopemap exported"); }
private Image LoadFromBinary(byte[] data, byte height, byte width, uint bits) { #region LoadData bool[] idata = new bool[data.Length * 8]; int bitnum = 0; for (int inc = 0; inc < data.Length; inc++) { if ((data[inc] & 1) == 1) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 2) == 2) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 4) == 4) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 8) == 8) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 16) == 16) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 32) == 32) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 64) == 64) { idata[bitnum] = true; } bitnum++; if ((data[inc] & 128) == 128) { idata[bitnum] = true; } bitnum++; } #endregion bitnum = 0; Image i = new Image(width, height); //for (uint y = 0; y < height; y++) for (uint x = 0; x < width; x++) { //for (uint x = 0; x < width; x++) for (uint y = 0; y < height; y++) { if (bitnum >= bits) { break; } if (idata[bitnum]) { bitnum++; if (idata[bitnum]) { bitnum++; i.SetPixel(x, y, Colors.Black); // Color the pixel white } else { bitnum++; bool[] tmp = new bool[8]; Array.Copy(idata, bitnum, tmp, 0, 8); bitnum += 8; byte greyscale = ReadByte(tmp); i.SetPixel(x, y, new Pixel(greyscale, greyscale, greyscale, 255)); } } else { bitnum++; i.SetPixel(x, y, Colors.White); // Color the pixel black } } if (bitnum >= bits) { break; } } return i; }
static Image ReadBitmapData(Stream input, VbpFileHeader fileHeader, VbpInformationHeader infoHeader) { input.Position = fileHeader.OffBits; int count = (infoHeader.Width * infoHeader.Height) * 2; byte[] buffer = new byte[count]; input.Read(buffer, 0, count); Image bitmap = new Image(infoHeader.Width, infoHeader.Height); int shift = GetShift(infoHeader.ColorMask.R); int num3 = GetShift(infoHeader.ColorMask.G); int num4 = GetShift(infoHeader.ColorMask.B); int num5 = 0; for (int i = 0; i < infoHeader.Height; i++) { for (int j = 0; j < infoHeader.Width; j++) { ushort num8 = BitConverter.ToUInt16(buffer, num5++ * 2); ushort red = (ushort)_colorTable5Bit[(num8 & infoHeader.ColorMask.R) >> shift]; ushort green = (ushort)_colorTable5Bit[(num8 & infoHeader.ColorMask.G) >> num3]; ushort blue = (ushort)_colorTable5Bit[(num8 & infoHeader.ColorMask.B) >> num4]; Pixel color = new Pixel((byte)red, (byte)green, (byte)blue, 255); bitmap.SetPixel((uint)j, (uint)i, color); } } return bitmap; }
public override void Render(Image im, BoundingBox clip, AffineTransform tx, string text, Vec2 loc, Pixel color) { if (text == null || text.Length == 0) return; int offset = 0, x = 0, y = 0, bdfFontDepth = bdfFont.getDepth(), x_min = int.MaxValue, y_min = int.MaxValue, x_max = int.MinValue, y_max = int.MinValue, charsCount = text.Length, fHeight, scan, fg_r, fg_g, fg_b, bx, by, offsetLine, fPixel, px, py, bg_r, bg_g, bg_b, r, g, b ; int[] fData; Vec2 src, dst; BDFParser.Rectangle glyph_box = new BDFParser.Rectangle(); BDFGlyph glyph; Image img; if ((bdfFont != null) && (charsCount > 0)) { char[] chrs = text.ToCharArray(); int mH = 0; int mY = 0; int mxY = 0; int tW = 0; int tH = 0; for (uint m = 0; m < text.Length; m++) { glyph = bdfFont.getGlyph(chrs[m]); glyph_box = glyph.getBbx(glyph_box); if (glyph_box.height > mH) { mH = glyph_box.height + 2; } if (glyph_box.y < mY) { mY = glyph_box.y; } if (glyph_box.y > mxY) { mxY = glyph_box.y; } tW += glyph_box.width + glyph_box.x + 2; } tH = mH + (mxY - mY); y = mH + -mY; img = new Image(tW, tH); float f_max = (1 << bdfFontDepth) - 1; if (f_max == 0) f_max = 1; glyph_box = new BDFParser.Rectangle(); src = new Vec2(); dst = new Vec2(); for (int i = 0; i < charsCount; i++) { glyph = bdfFont.getGlyph(chrs[i]); if (glyph == null) { continue; } glyph_box = glyph.getBbx(glyph_box); fHeight = glyph_box.height; fData = glyph.getData(); scan = fData.Length / fHeight; fg_r = color.R; fg_g = color.G; fg_b = color.B; //box location bx = x + offset + glyph_box.x; by = y - fHeight - glyph_box.y; for (int k = 0; k < fHeight; k++) { offsetLine = k * scan; for (int j = 0; j < scan; j++) { fPixel = fData[offsetLine + j]; if (fPixel != 0) { //pixel location px = bx + j; py = by + k; if (tx != null) { //src.setLocation(px, py); //tx.transform(src, dst); #warning TODO: Add support for this. //px = dst.X; //py = dst.Y; } //clip if (clip == null || clip.Contains(px, py)) { //compute color Pixel bg_color = img.GetPixel((uint)px, (uint)py); bg_r = bg_color.R; bg_g = bg_color.G; bg_b = bg_color.B; //todo improve this pixel composition float alpha = fPixel / f_max; r = bg_r + ((int)((fg_r - bg_r) * alpha)) & 0xFF; g = bg_g + ((int)((fg_g - bg_g) * alpha)) & 0xFF; b = bg_b + ((int)((fg_b - bg_b) * alpha)) & 0xFF; Pixel nw = new Pixel((byte)r, (byte)g, (byte)b, 255); img.SetPixel((uint)px, (uint)py, nw); if (x_min > px) x_min = px; if (y_min > py) y_min = py; if (x_max < px) x_max = px; if (y_max < py) y_max = py; } } } } offset += glyph.getDWidth().width; } //img = ImageManipulator.Resize(img, new Vec2(img.Width * 8, img.Height * 8), ImageManipulator.ScalingAlgorithm.Bicubic); //img = ImageManipulator.Resize(img, Vec2.Zero, ImageManipulator.ScalingAlgorithm.Hq2x); //img = ImageManipulator.Resize(img, Vec2.Zero, ImageManipulator.ScalingAlgorithm.Hq4x); im.DrawImage(loc, img); } }
public void Save(string filename) { double[,] mesh = Terrain.GetInstance().Map; int width = mesh.GetUpperBound(0) + 1; int height = mesh.GetUpperBound(1) + 1; Image image = new Image(width, height); //Bitmap bitmap = new Bitmap( width, height, PixelFormat.Format24bppRgb ); //Graphics g = Graphics.FromImage(bitmap); //Pen[] pens = new Pen[256]; //for (int i = 0; i < 256; i++) //{ // pens[i] = new Pen(System.Drawing.Color.FromArgb(i, i, i)); //} double minheight = Config.GetInstance().minheight; double maxheight = Config.GetInstance().maxheight; double heightmultiplier = 255 / (maxheight - minheight); for (int i = 0; i < width; i++) { for( int j = 0; j < height; j++ ) { int normalizedmeshvalue = (int)( (mesh[i, j] - minheight) * heightmultiplier ); normalizedmeshvalue = Math.Max( 0,normalizedmeshvalue ); normalizedmeshvalue = Math.Min( 255,normalizedmeshvalue ); byte normalizedmeshvaluebyte = (byte)normalizedmeshvalue; image.SetPixel(i, j, normalizedmeshvaluebyte, normalizedmeshvaluebyte, normalizedmeshvaluebyte, 255); //g.DrawRectangle(pens[ normalizedmeshvalue ], i, j, 1, 1); } } if (File.Exists(filename)) { File.Delete(filename); } image.Save(filename); //DevIL.DevIL.SaveBitmap(filename, bitmap); //bitmap.Save(filename, ImageFormat.Bmp); Terrain.GetInstance().HeightmapFilename = filename; Terrain.GetInstance().OnTerrainModified(); MainUI.GetInstance().uiwindow.InfoMessage("Heightmap saved"); }
private Image LoadFromBinary(byte[] data, byte height, byte width, int bits) { MemoryStream m = new MemoryStream(data); BinaryReader br = new BinaryReader(m); Image i = new Image(width, height); for (uint x = 0; x < width; x++) //for (uint y = 0; y < height; y++) { for (uint y = 0; y < height; y++) //for (uint x = 0; x < width; x++) { //if (br.ReadBoolean()) //{ // if (br.ReadBoolean()) // { // i.SetPixel(x, y, Colors.Black); // Color the pixel black // } // else // { byte greyscale = br.ReadByte(); if (greyscale != 255) { i.SetPixel(x, y, new Pixel(greyscale, greyscale, greyscale, 255)); // Color the pixel as greyscale } // } //} //else //{ // i.SetPixel(x, y, Colors.White); // Color the pixel white //} } } data = null; br.Dispose(); m.Dispose(); return i; }
public static Image Load(Stream input) { string str; if (ReadLine(input, out str) || (str.Trim().Substring(0, 6).CompareTo("/* XPM") != 0)) { throw new Exception("No valid XPM header found"); } do { if (ReadLine(input, out str)) { throw new Exception("Cannot find the values section of the file"); } } while (str.Trim().Substring(0, 1).CompareTo("\"") != 0); char[] separator = new char[] { ' ', '\t', '"' }; string[] strArray = str.Split(separator); if (strArray.Length < 6) { throw new Exception("Invalid values section of the file"); } int width = Convert.ToInt32(strArray[1]); int height = Convert.ToInt32(strArray[2]); int num3 = Convert.ToInt32(strArray[3]); int length = Convert.ToInt32(strArray[4]); Image image = new Image(width, height); do { if (ReadLine(input, out str)) { throw new Exception("Cannot find the color section of the file"); } } while (str.Trim().Substring(0, 1).CompareTo("\"") != 0); Dictionary<string, Pixel> dictionary = new Dictionary<string, Pixel>(); for (int i = 0; i < num3; i++) { string str2 = str.Trim(); string key = str2.Substring(1, length); strArray = str2.Substring(length + 1).Split(separator); if (strArray.Length < 4) { throw new Exception("Invalid color entry"); } if (strArray[1].CompareTo("c") != 0) { throw new Exception("Non color type found, unhandled"); } if (strArray[2].CompareTo("None") == 0) { Pixel color = new Pixel(true); dictionary.Add(key, color); } else { if (strArray[2].Substring(0, 1).CompareTo("#") != 0) { throw new Exception("Non RGB color type found, unhandled"); } byte red = (byte)Convert.ToInt32(strArray[2].Substring(1, 2), 0x10); byte green = (byte)Convert.ToInt32(strArray[2].Substring(3, 2), 0x10); byte blue = (byte)Convert.ToInt32(strArray[2].Substring(5, 2), 0x10); Pixel color2 = new Pixel(red, green, blue, 255); dictionary.Add(key, color2); } if (ReadLine(input, out str)) { throw new Exception("Corrupt color section in the file"); } } do { if (ReadLine(input, out str)) { throw new Exception("Cannot find the pixel section of the file"); } } while (str.Trim().Substring(0, 1).CompareTo("\"") != 0); for (int j = 0; j < height; j++) { string str4 = str.Trim(); if (str4.Substring(1).IndexOf('"') != (width * length)) { throw new Exception("Corrupt pixel entry in the file"); } int startIndex = 1; int x = 0; while (x < width) { Pixel color3; string str5 = str4.Substring(startIndex, length); if (!dictionary.TryGetValue(str5, out color3)) { throw new Exception("Unknown pixel value - weird"); } image.SetPixel((uint)x, (uint)j, color3); x++; startIndex += length; } if (ReadLine(input, out str)) { throw new Exception("Corrupt pixel section in the file"); } } return image; }
/// <summary> /// Decodes the image from the specified _stream and sets /// the data to image. /// </summary> /// <param name="image">The image, where the data should be set to. /// Cannot be null (Nothing in Visual Basic).</param> /// <param name="stream">The _stream, where the image should be /// decoded from. Cannot be null (Nothing in Visual Basic).</param> /// <exception cref="ArgumentNullException"> /// <para><paramref name="image"/> is null (Nothing in Visual Basic).</para> /// <para>- or -</para> /// <para><paramref name="stream"/> is null (Nothing in Visual Basic).</para> /// </exception> public Image Decode(Stream stream) { _stream = stream; try { ReadFileHeader(); ReadInfoHeader(); int colorMapSize = -1; if (_infoHeader.ClrUsed == 0) { if (_infoHeader.BitsPerPixel == 1 || _infoHeader.BitsPerPixel == 4 || _infoHeader.BitsPerPixel == 8) { colorMapSize = (int)Math.Pow(2, _infoHeader.BitsPerPixel) * 4; } } else { colorMapSize = _infoHeader.ClrUsed * 4; } byte[] palette = null; if (colorMapSize > 0) { palette = new byte[colorMapSize]; _stream.Read(palette, 0, colorMapSize); } byte[] imageData = new byte[_infoHeader.Width * _infoHeader.Height * 4]; switch (_infoHeader.Compression) { case BmpCompression.RGB: if (_infoHeader.HeaderSize != 40) { throw new Exception("Header Size value '" + _infoHeader.HeaderSize.ToString() + "' is not valid."); } if (_infoHeader.BitsPerPixel == 32) { ReadRgb32(imageData, _infoHeader.Width, _infoHeader.Height); } else if (_infoHeader.BitsPerPixel == 24) { ReadRgb24(imageData, _infoHeader.Width, _infoHeader.Height); } else if (_infoHeader.BitsPerPixel == 16) { ReadRgb16(imageData, _infoHeader.Width, _infoHeader.Height); } else if (_infoHeader.BitsPerPixel <= 8) { ReadRgbPalette(imageData, palette, _infoHeader.ImageSize, _infoHeader.Width, _infoHeader.Height, _infoHeader.BitsPerPixel); } break; default: throw new NotSupportedException("Does not support this kind of bitmap files."); } Image i = new Image(_infoHeader.Width, _infoHeader.Height); int indx = 0; byte r, g, b, a; for (uint y = 0; y < i.Height; y++) { for (uint x = 0; x < i.Width; x++) { r = imageData[indx]; indx++; g = imageData[indx]; indx++; b = imageData[indx]; indx++; a = imageData[indx]; indx++; i.SetPixel(x, y, new Pixel(r, g, b, a)); } } imageData = null; System.GC.Collect(); return i; } catch (IndexOutOfRangeException e) { throw new Exception("Bitmap does not have a valid format.", e); } }
public void Image_Compare() { Map m1 = new Map(256, 256); Map m2 = new Map(256, 256); Image i1 = new Image(256, 256); Image i2 = new Image(256, 256); Assert.AreEqual(i1.Compare(i2), 0); i1.SetPixel(0, 0, new Color("white")); Assert.AreEqual(i1.Compare(i2), 1); m1.Background = new Color("black"); m1.Render(i1); Assert.AreEqual(i1.Width() * i1.Height(), i1.Compare(i2)); //test options m1.Background= new Color(100, 100, 100, 255); m1.Render(i1); i2 = new Image(256, 256); m2.Background = new Color(100,100,100,100); m2.Render(i2); Dictionary<string, object> options; options = new Dictionary<string, object> { { "Alpha", false } }; Assert.AreEqual(i1.Compare(i2, options), 0); m1.Background = new Color(255, 255, 255); m1.Render(i1); m2.Background = new Color(255, 255, 255); m2.Render(i2); i2.SetPixel(0, 0, new Color(250, 250, 250)); options = new Dictionary<string, object> { { "Threshold", 5 } }; Assert.AreEqual(i1.Compare(i2, options), 0); }
// what we need to do is to render the splatted texture in ortho mode with lighting off // or normals off (to be tested) // then to export the generated bitmap // viewport should be set to heightmapwidth x heightmapheight public void Export(string filepath) { Terrain terrain = Terrain.GetInstance(); int picturewidth = terrain.MapWidth * Terrain.SquareSize; int pictureheight = terrain.MapHeight * Terrain.SquareSize; LogFile.GetInstance().WriteLine("Export to " + filepath + " picturewidth " + picturewidth + " pictureheight: " + pictureheight); //int windowwidth = RendererSdl.GetInstance().WindowWidth; //int windowheight = RendererSdl.GetInstance().WindowHeight; int windowwidth = 256; int windowheight = 256; Gl.glViewport(0, 0, windowwidth, windowheight); byte[] buffer = new byte[windowwidth * windowheight * 4]; //System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap( picturewidth, pictureheight ); //byte[] imagedata = new byte[picturewidth * pictureheight * 4]; Image image = new Image(picturewidth, pictureheight); List<RendererPass> rendererpasses = new List<RendererPass>(); bool multipass = true; // force multipass for now for simplicity int maxtexels = RendererSdl.GetInstance().MaxTexelUnits; if (multipass) { for (int i = 0; i < terrain.texturestages.Count; i++) { MapTextureStage maptexturestage = terrain.texturestages[i]; int numtexturestagesrequired = maptexturestage.NumTextureStagesRequired; if (numtexturestagesrequired > 0) // exclude Nops { RendererPass rendererpass = new RendererPass(maxtexels); for (int j = 0; j < maptexturestage.NumTextureStagesRequired; j++) { rendererpass.AddStage(new RendererTextureStage(maptexturestage, j, true, picturewidth, pictureheight)); } rendererpasses.Add(rendererpass); } } } GraphicsHelperGl g = new GraphicsHelperGl(); Gl.glMatrixMode(Gl.GL_PROJECTION); Gl.glPushMatrix(); Gl.glLoadIdentity(); Gl.glOrtho(0, windowwidth, windowheight, 0, -1, 1); Gl.glMatrixMode(Gl.GL_MODELVIEW); Gl.glPushMatrix(); Gl.glLoadIdentity(); Gl.glDisable(Gl.GL_CULL_FACE); Gl.glDisable(Gl.GL_LIGHTING); g.EnableBlendSrcAlpha(); Gl.glDepthFunc( Gl.GL_LEQUAL ); for (int chunkx = 0; chunkx < Math.Ceiling((double)picturewidth / windowwidth); chunkx++) { for (int chunky = 0; chunky < Math.Ceiling((double)pictureheight / windowheight); chunky++) { Console.WriteLine("chunkx " + chunkx + " chunky " + chunky); Gl.glClear(Gl.GL_COLOR_BUFFER_BIT | Gl.GL_DEPTH_BUFFER_BIT); // Clear The Screen And Depth Buffer foreach (RendererPass rendererpass in rendererpasses) { rendererpass.Apply(); Gl.glBegin(Gl.GL_QUADS); double ul = (chunkx * windowwidth); double ur = (chunkx * windowwidth + windowwidth); double vt = (chunky * windowheight); double vb = (chunky * windowheight + windowheight); Gl.glTexCoord2d( ul,vt ); Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB,ul, vt); Gl.glVertex2i(0, 0); Gl.glTexCoord2d( ul,vb ); Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB,ul, vb); Gl.glVertex2i(0, windowheight); Gl.glTexCoord2d( ur,vb ); Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB,ur, vb); Gl.glVertex2i(windowwidth, windowheight); Gl.glTexCoord2d( ur,vt ); Gl.glMultiTexCoord2dARB(Gl.GL_TEXTURE1_ARB,ur, vt); Gl.glVertex2i(windowwidth, 0); Gl.glEnd(); } IntPtr ptr = Marshal.AllocHGlobal(windowwidth * windowheight * 4); Gl.glReadPixels(0, 0, windowwidth, windowheight, Gl.GL_RGBA, Gl.GL_UNSIGNED_BYTE, ptr); Marshal.Copy(ptr, buffer, 0, windowwidth * windowheight * 4); Marshal.FreeHGlobal(ptr); for (int x = 0; x < windowwidth; x++) { for (int y = 0; y < windowheight; y++) { if ((chunky * windowheight + y < pictureheight) && (chunkx * windowwidth + x < picturewidth)) { int pixeloffset = (windowheight - y - 1) * windowwidth * 4 + x * 4; //bitmap.SetPixel(x + chunkx * windowwidth, y + chunky * windowheight, System.Drawing.Color.FromArgb(buffer[pixeloffset + 0], //buffer[pixeloffset + 1], buffer[pixeloffset + 2])); image.SetPixel(x + chunkx * windowwidth, y + chunky * windowheight, buffer[pixeloffset + 0], buffer[pixeloffset + 1], buffer[pixeloffset + 2], 255 ); } } } } } if (File.Exists(filepath)) { File.Delete(filepath); } image.Save(filepath); //DevIL.DevIL.SaveBitmap( filepath, bitmap); Gl.glPopMatrix(); Gl.glMatrixMode(Gl.GL_PROJECTION); Gl.glPopMatrix(); Gl.glMatrixMode(Gl.GL_MODELVIEW); Gl.glEnable(Gl.GL_LIGHTING); g.ActiveTexture(1); g.DisableTexture2d(); g.SetTextureScale(1); g.ActiveTexture(0); g.SetTextureScale(1); Gl.glEnable(Gl.GL_CULL_FACE); Gl.glEnable(Gl.GL_LIGHTING); Gl.glDisable(Gl.GL_BLEND); g.EnableModulate(); Gl.glViewport(0, 0, RendererSdl.GetInstance().OuterWindowWidth, RendererSdl.GetInstance().OuterWindowHeight); g.CheckError(); MainUI.GetInstance().uiwindow.InfoMessage("Exported blended terrain texture to " + filepath); }
private void ReadFrameColors(byte[] indices, byte[] colorTable, GifImageDescriptor descriptor) { int imageWidth = _logicalScreenDescriptor.Width; int imageHeight = _logicalScreenDescriptor.Height; if (_currentFrame == null) { _currentFrame = new byte[imageWidth * imageHeight * 4]; } byte[] lastFrame = null; if (_graphicsControl != null && _graphicsControl.DisposalMethod == DisposalMethod.RestoreToPrevious) { lastFrame = new byte[imageWidth * imageHeight * 4]; Array.Copy(_currentFrame, lastFrame, lastFrame.Length); } int offset = 0, i = 0, index = -1; int iPass = 0; // the interlace pass int iInc = 8; // the interlacing line increment int iY = 0; // the current interlaced line int writeY = 0; // the target y offset to write to for (int y = descriptor.Top; y < descriptor.Top + descriptor.Height; y++) { // Check if this image is interlaced. if (descriptor.InterlaceFlag) { // If so then we read lines at predetermined offsets. // When an entire image height worth of offset lines has been read we consider this a pass. // With each pass the number of offset lines changes and the starting line changes. if (iY >= descriptor.Height) { iPass++; switch (iPass) { case 1: iY = 4; break; case 2: iY = 2; iInc = 4; break; case 3: iY = 1; iInc = 2; break; } } writeY = iY + descriptor.Top; iY += iInc; } else { writeY = y; } for (int x = descriptor.Left; x < descriptor.Left + descriptor.Width; x++) { offset = writeY * imageWidth + x; index = indices[i]; if (_graphicsControl == null || _graphicsControl.TransparencyFlag == false || _graphicsControl.TransparencyIndex != index) { _currentFrame[offset * 4 + 0] = colorTable[index * 3 + 0]; _currentFrame[offset * 4 + 1] = colorTable[index * 3 + 1]; _currentFrame[offset * 4 + 2] = colorTable[index * 3 + 2]; _currentFrame[offset * 4 + 3] = (byte)255; } i++; } } byte[] pixels = new byte[imageWidth * imageHeight * 4]; Array.Copy(_currentFrame, pixels, pixels.Length); _currentFrame = new byte[imageWidth * imageHeight * 4]; Image frame = new Image(imageWidth, imageHeight); int indx = 0; byte r, g, b, a; for (uint y = 0; y < frame.Height; y++) { for (uint x = 0; x < frame.Width; x++) { r = pixels[indx]; indx++; g = pixels[indx]; indx++; b = pixels[indx]; indx++; a = pixels[indx]; indx++; frame.SetPixel(x, y, new Pixel(r, g, b, a)); } } pixels = null; System.GC.Collect(); _image.AddFrame(frame); if (_graphicsControl != null) { if (_graphicsControl.DelayTime > 0) { _image.TimePerFrame = _graphicsControl.DelayTime; } if (_graphicsControl.DisposalMethod == DisposalMethod.RestoreToBackground) { Image im = new Image(imageWidth, imageHeight); im.Clear(new Pixel(true)); _image.AddFrame(im); _image.Loop = false; } else if (_graphicsControl.DisposalMethod == DisposalMethod.RestoreToPrevious) { _image.Loop = true; } } }