public void TestConvertArgb32Image() { String imgPath0 = "..\\images\\yilagou_1280_720_24.jpg"; Bitmap map = new Bitmap(imgPath0); Color c = map.GetPixel(0, 0); Console.WriteLine(c.ToString()); ImageArgb32 r = new ImageArgb32(map); Argb32 cr = r[0, 0]; Console.WriteLine(cr.ToString()); Bitmap to = r.ToBitmap(); Color tc = to.GetPixel(0, 0); Console.WriteLine(tc.ToString()); Assert.AreEqual(c.A, cr.Alpha); Assert.AreEqual(c.R, cr.Red); Assert.AreEqual(c.G, cr.Green); Assert.AreEqual(c.B, cr.Blue); Assert.AreEqual(c.R, tc.R); Assert.AreEqual(c.G, tc.G); Assert.AreEqual(c.B, tc.B); }
public void CloneAs_ToArgb32(TestImageProvider <Rgba32> provider) { using (Image <Rgba32> image = provider.GetImage()) using (Image <Argb32> clone = image.CloneAs <Argb32>()) { for (int y = 0; y < image.Height; y++) { Span <Rgba32> row = image.GetPixelRowSpan(y); Span <Argb32> rowClone = clone.GetPixelRowSpan(y); for (int x = 0; x < image.Width; x++) { Rgba32 expected = row[x]; Argb32 actual = rowClone[x]; Assert.Equal(expected.R, actual.R); Assert.Equal(expected.G, actual.G); Assert.Equal(expected.B, actual.B); Assert.Equal(expected.A, actual.A); } } } }
public void FromArgb32(Argb32 source) => this.FromScaledVector4(source.ToScaledVector4());
public void PackFromArgb32(Argb32 source) { PackedValue = FromLinearRgb(source.R, source.G, source.B); }
protected override Argb32 GetDeltaColor(Argb32 baseColor, Argb32 variantColor) { unchecked { return(new Argb32((byte)(variantColor.R - baseColor.R), (byte)(variantColor.G - baseColor.G), (byte)(variantColor.B - baseColor.B), (byte)(variantColor.A - baseColor.A))); } }
protected override Argb32 GetVariantColor(Argb32 baseColor, Argb32 deltaColor) { unchecked { return(new Argb32((byte)(baseColor.R + deltaColor.R), (byte)(baseColor.G + deltaColor.G), (byte)(baseColor.B + deltaColor.B), (byte)(baseColor.A + deltaColor.A))); } }
protected override Argb32 GetVariantColor(Argb32 baseColor, Argb32 deltaColor) => deltaColor == new Argb32(0, 0, 0, 0) ? baseColor : deltaColor;
protected override Argb32 GetDeltaColor(Argb32 baseColor, Argb32 variantColor) => baseColor == variantColor ? new Argb32(0, 0, 0, 0) : variantColor;
public void FromArgb32(Argb32 source) { }
public Color(Argb32 pixel) { this.data = new Rgba64(pixel); this.boxedHighPrecisionPixel = null; }
/// <inheritdoc /> public void FromArgb32(Argb32 source) { throw new NotImplementedException(); }
// Create a screen from an image. public static Screen FromImage(Image <Argb32> img, bool optimizeGraphic, bool affine, bool is4Bpp, bool firstColorTransparent, bool isEnpg, int graphicWidthTiles, int graphicHeightTiles, int colorsPerPalette, Argb32?backgroundColor) { // TODO: ADD SUPPORT FOR OPTIMIZING THE GRAPHIC! (Identical tiles, flips, etc.) // Dimensions check. if (!optimizeGraphic) { if (img.Width != graphicWidthTiles * 8 || img.Height != graphicHeightTiles * 8) { throw new Exception("Image size must be " + (graphicWidthTiles * 8) + "x" + (graphicHeightTiles * 8) + "!"); } } else { if (img.Width % 8 != 0 || img.Height % 8 != 0) { throw new Exception("Image size must be a multiple of 8 in both dimensions!"); } } // Create stuff. Screen s = new Screen(); s.Affine = affine; s.Graphic = new Graphic(); s.Graphic.FirstColorTransparent = firstColorTransparent; s.Graphic.Is4BPP = is4Bpp; s.Graphic.IsEnpg = isEnpg; s.Graphic.Tiles = new Graphic.Tile[graphicWidthTiles, graphicHeightTiles]; s.Graphic.Palette = new Palette(); s.Graphic.Palette.IndexSize = colorsPerPalette; // Take into account background/transparent color. bool oneLessColor = backgroundColor != null || firstColorTransparent; int numColorsToGenerate = colorsPerPalette; if (oneLessColor) { numColorsToGenerate--; } if (firstColorTransparent) { backgroundColor = new Argb32(0, 0, 0, 0); } // Get the graphic. int[,] newGraphic; s.Graphic.Palette.Colors = Palette.LimitColorPalette(img, numColorsToGenerate, backgroundColor, out newGraphic); if (oneLessColor) { s.Graphic.Palette.Colors.Insert(0, new RGB5(0)); } for (int i = 0; i < graphicWidthTiles * 8; i++) { for (int j = 0; j < graphicHeightTiles * 8; j++) { int tileX = i / 8; int tileY = j / 8; int pixelX = i % 8; int pixelY = j % 8; if (pixelX == 0 && pixelY == 0) { s.Graphic.Tiles[tileX, tileY] = new Graphic.Tile(); } s.Graphic.Tiles[tileX, tileY].Colors[pixelX, pixelY] = (byte)newGraphic[i, j]; } } var sTemp = Screen.GenerateDefault(s.Graphic); s.Tiles = sTemp.Tiles; while (s.Graphic.Palette.Colors.Count < s.Graphic.Palette.IndexSize) { s.Graphic.Palette.Colors.Add(new RGB5()); } // Return the final screen. return(s); }
public void PackFromArgb32(Argb32 source) { this = FromRgba(source.R, source.G, source.B, source.A); }
public void PackFromArgb32(Argb32 source) => Pack(source.R, source.G, source.B);
protected abstract Argb32 GetVariantColor(Argb32 baseColor, Argb32 deltaColor);
public static void SaveMazeAsImageDeluxePng(InnerMap map, List <MazePointPos> pathPosjes, Stream stream) { pathPosjes.Sort((first, second) => { if (first.Y == second.Y) { return(first.X - second.X); } return(first.Y - second.Y); }); int curpos = 0; var w = Stopwatch.StartNew(); var image = new Image <Argb32>(map.Width - 1, map.Height - 1); using (var pixels = image.Lock()) { for (int y = 0; y < map.Height - 1; y++) { for (int x = 0; x < map.Width - 1; x++) { int r = 0; int g = 0; int b = 0; MazePointPos curPathPos; if (curpos < pathPosjes.Count) { curPathPos = pathPosjes[curpos]; if (curPathPos.X == x && curPathPos.Y == y) { r = curPathPos.RelativePos; g = 255 - curPathPos.RelativePos; b = 0; curpos++; } else if (map[x, y]) { r = 255; g = 255; b = 255; } } else if (map[x, y]) { r = 255; g = 255; b = 255; } pixels[x, y] = new Argb32((byte)r, (byte)g, (byte)b); } //lineSavingProgress(y, this.Height - 2); } } var timeForFirstImageSavePart = w.Elapsed; w.Restart(); var pngEncored = new PngEncoder(); image.Save(stream, pngEncored, new PngEncoderOptions() { CompressionLevel = 9 }); //image.SaveAsPng(stream); var timeForSaveAsPng = w.Elapsed; Console.WriteLine($"First image conversion time: {timeForFirstImageSavePart}, Time for saving as PNG: {timeForSaveAsPng}"); }