将透明 PNG 保存为透明 GIF
Posted
技术标签:
【中文标题】将透明 PNG 保存为透明 GIF【英文标题】：Saving Transparent PNG as Transparent GIF 【发布时间】：2015-09-28 13:51:55 【问题描述】：我正在尝试调整透明 png 的大小并将其保存为单帧 gif 图像。 让我们跳过调整大小的部分，当您尝试将透明 png 保存为 gif 时，您会在输出 gif 中看到黑色背景：
Bitmap n = new Bitmap(targetPngPath);
n.Save(@"C:\1.gif", ImageFormat.Gif);
是的，我可以将黑色背景变成白色，但这不是我想要的。即使我可以使用MakeTransparent 方法去除黑色，但它会去除图像中的几乎所有黑色，并且我们不会有标准的透明图像。
我们也可以做一个 TRICK 保存 gif 图像，我们在文件名中保留扩展名，但我们会将其保存为 PNG 格式，如下所示：
n.Save(@"C:\1.gif", ImageFormat.Png);
但这也不是标准的。 那么有什么方法可以安全地将透明的png保存为具有透明度的gif图像呢？
PNG = GIF =
用 Photoshop 保存的 GIF =
【问题讨论】：
输出 gif 中的黑色背景 - 它是来自加载、调整大小还是保存？ 保存后会出现黑色背景 技术上 GIF 透明度意味着一种单一颜色（最多 256 种）被认为是透明的。 PNG 透明度不同 - 它包含 alpha（透明度）层。如果你能找到GIF中没有用到的颜色，然后用这个颜色替换PNG透明部分，使其透明并保存，那么你应该成功了。 我认为你错了，当你convert png into bitmap（正在加载）时它变成黑色。一个愚蠢的解决方案可能是使用图像中不存在的某种颜色作为背景，然后在保存之前使用MakeTransparent该颜色。
这里的“技巧”并不是真正的技巧，因为它在各个方面仍然是 PNG。
【参考方案1】：
这是因为内置的 GIF 编码器不能很好地处理源，除非它已经是 8 bpp 图像。您必须先将您的 PNG 图片转换为 256 色图片，然后才能使用 GIF 编码器正确保存。
public static void SaveGif(string fileName, Image image)
int bpp = Image.GetPixelFormatSize(image.PixelFormat);
if (bpp == 8)
image.Save(fileName, ImageFormat.Gif);
return;
// 1 and 4 bpp images are need to be converted, too; otherwise, gif encoder encodes the image from 32 bpp image resulting 256 color, no transparency
if (bpp < 8)
using (Image image8Bpp = ConvertPixelFormat(image, PixelFormat.Format8bppIndexed, null))
image8Bpp.Save(fileName, ImageFormat.Gif);
return;
// high/true color bitmap: obtaining the colors
// Converting always to 8 bpp pixel format; otherwise, gif encoder would convert it to 32 bpp first.
// With 8 bpp, gif encoder will preserve transparency and will save compact palette
// Note: This works well for 256 color images in a 32bpp bitmap. Otherwise, you might try to pass null as palette so a default palette will be used.
Color[] palette = GetColors((Bitmap)image, 256);
using (Image imageIndexed = ConvertPixelFormat(image, PixelFormat.Format8bppIndexed, palette))
imageIndexed.Save(fileName, ImageFormat.Gif);
// TODO: Use some quantizer
private static Color[] GetColors(Bitmap bitmap, int maxColors)
if (bitmap == null)
throw new ArgumentNullException("bitmap");
if (maxColors < 0)
throw new ArgumentOutOfRangeException("maxColors");
HashSet<int> colors = new HashSet<int>();
PixelFormat pixelFormat = bitmap.PixelFormat;
if (Image.GetPixelFormatSize(pixelFormat) <= 8)
return bitmap.Palette.Entries;
// 32 bpp source: the performant variant
if (pixelFormat == PixelFormat.Format32bppRgb ||
pixelFormat == PixelFormat.Format32bppArgb ||
pixelFormat == PixelFormat.Format32bppPArgb)
BitmapData data = bitmap.LockBits(new Rectangle(Point.Empty, bitmap.Size), ImageLockMode.ReadOnly, pixelFormat);
try
unsafe
byte* line = (byte*)data.Scan0;
for (int y = 0; y < data.Height; y++)
for (int x = 0; x < data.Width; x++)
int c = ((int*)line)[x];
// if alpha is 0, adding the transparent color
if ((c >> 24) == 0)
c = 0xFFFFFF;
if (colors.Contains(c))
continue;
colors.Add(c);
if (colors.Count == maxColors)
return colors.Select(Color.FromArgb).ToArray();
line += data.Stride;
finally
bitmap.UnlockBits(data);
else
// fallback: getpixel
for (int y = 0; y < bitmap.Height; y++)
for (int x = 0; x < bitmap.Width; x++)
int c = bitmap.GetPixel(x, y).ToArgb();
if (colors.Contains(c))
continue;
colors.Add(c);
if (colors.Count == maxColors)
return colors.Select(Color.FromArgb).ToArray();
return colors.Select(Color.FromArgb).ToArray();
private static Image ConvertPixelFormat(Image image, PixelFormat newPixelFormat, Color[] palette)
if (image == null)
throw new ArgumentNullException("image");
PixelFormat sourcePixelFormat = image.PixelFormat;
int bpp = Image.GetPixelFormatSize(newPixelFormat);
if (newPixelFormat == PixelFormat.Format16bppArgb1555 || newPixelFormat == PixelFormat.Format16bppGrayScale)
throw new NotSupportedException("This pixel format is not supported by GDI+");
Bitmap result;
// non-indexed target image (transparency preserved automatically)
if (bpp > 8)
result = new Bitmap(image.Width, image.Height, newPixelFormat);
using (Graphics g = Graphics.FromImage(result))
g.DrawImage(image, 0, 0, image.Width, image.Height);
return result;
int transparentIndex;
Bitmap bmp;
// indexed colors: using GDI+ natively
RGBQUAD[] targetPalette = new RGBQUAD[256];
int colorCount = InitPalette(targetPalette, bpp, (image is Bitmap) ? image.Palette : null, palette, out transparentIndex);
BITMAPINFO bmi = new BITMAPINFO();
bmi.icHeader.biSize = (uint)Marshal.SizeOf(typeof(BITMAPINFOHEADER));
bmi.icHeader.biWidth = image.Width;
bmi.icHeader.biHeight = image.Height;
bmi.icHeader.biPlanes = 1;
bmi.icHeader.biBitCount = (ushort)bpp;
bmi.icHeader.biCompression = BI_RGB;
bmi.icHeader.biSizeImage = (uint)(((image.Width + 7) & 0xFFFFFFF8) * image.Height / (8 / bpp));
bmi.icHeader.biXPelsPerMeter = 0;
bmi.icHeader.biYPelsPerMeter = 0;
bmi.icHeader.biClrUsed = (uint)colorCount;
bmi.icHeader.biClrImportant = (uint)colorCount;
bmi.icColors = targetPalette;
bmp = (image as Bitmap) ?? new Bitmap(image);
// Creating the indexed bitmap
IntPtr bits;
IntPtr hbmResult = CreateDIBSection(IntPtr.Zero, ref bmi, DIB_RGB_COLORS, out bits, IntPtr.Zero, 0);
// Obtaining screen DC
IntPtr dcScreen = GetDC(IntPtr.Zero);
// DC for the original hbitmap
IntPtr hbmSource = bmp.GetHbitmap();
IntPtr dcSource = CreateCompatibleDC(dcScreen);
SelectObject(dcSource, hbmSource);
// DC for the indexed hbitmap
IntPtr dcTarget = CreateCompatibleDC(dcScreen);
SelectObject(dcTarget, hbmResult);
// Copy content
BitBlt(dcTarget, 0, 0, image.Width, image.Height, dcSource, 0, 0, 0x00CC0020 /*TernaryRasterOperations.SRCCOPY*/);
// obtaining result
result = Image.FromHbitmap(hbmResult);
result.SetResolution(image.HorizontalResolution, image.VerticalResolution);
// cleanup
DeleteDC(dcSource);
DeleteDC(dcTarget);
ReleaseDC(IntPtr.Zero, dcScreen);
DeleteObject(hbmSource);
DeleteObject(hbmResult);
ColorPalette resultPalette = result.Palette;
bool resetPalette = false;
// restoring transparency
if (transparentIndex >= 0)
// updating palette if transparent color is not actually transparent
if (resultPalette.Entries[transparentIndex].A != 0)
resultPalette.Entries[transparentIndex] = Color.Transparent;
resetPalette = true;
ToIndexedTransparentByArgb(result, bmp, transparentIndex);
if (resetPalette)
result.Palette = resultPalette;
if (!ReferenceEquals(bmp, image))
bmp.Dispose();
return result;
private static int InitPalette(RGBQUAD[] targetPalette, int bpp, ColorPalette originalPalette, Color[] desiredPalette, out int transparentIndex)
int maxColors = 1 << bpp;
// using desired palette
Color[] sourcePalette = desiredPalette;
// or, using original palette if it has fewer or the same amount of colors as requested
if (sourcePalette == null && originalPalette != null && originalPalette.Entries.Length > 0 && originalPalette.Entries.Length <= maxColors)
sourcePalette = originalPalette.Entries;
// or, using default system palette
if (sourcePalette == null)
using (Bitmap bmpReference = new Bitmap(1, 1, GetPixelFormat(bpp)))
sourcePalette = bmpReference.Palette.Entries;
// it is ignored if source has too few colors (rest of the entries will be black)
transparentIndex = -1;
bool hasBlack = false;
int colorCount = Math.Min(maxColors, sourcePalette.Length);
for (int i = 0; i < colorCount; i++)
targetPalette[i] = new RGBQUAD(sourcePalette[i]);
if (transparentIndex == -1 && sourcePalette[i].A == 0)
transparentIndex = i;
if (!hasBlack && (sourcePalette[i].ToArgb() & 0xFFFFFF) == 0)
hasBlack = true;
// if transparent index is 0, relocating it and setting transparent index to 1
if (transparentIndex == 0)
targetPalette[0] = targetPalette[1];
transparentIndex = 1;
// otherwise, setting the color of transparent index the same as the previous color, so it will not be used during the conversion
else if (transparentIndex != -1)
targetPalette[transparentIndex] = targetPalette[transparentIndex - 1];
// if black color is not found in palette, counting 1 extra colors because it can be used in conversion
if (colorCount < maxColors && !hasBlack)
colorCount++;
return colorCount;
private unsafe static void ToIndexedTransparentByArgb(Bitmap target, Bitmap source, int transparentIndex)
int sourceBpp = Image.GetPixelFormatSize(source.PixelFormat);
int targetBpp = Image.GetPixelFormatSize(target.PixelFormat);
BitmapData dataTarget = target.LockBits(new Rectangle(Point.Empty, target.Size), ImageLockMode.ReadWrite, target.PixelFormat);
BitmapData dataSource = source.LockBits(new Rectangle(Point.Empty, source.Size), ImageLockMode.ReadOnly, source.PixelFormat);
try
byte* lineSource = (byte*)dataSource.Scan0;
byte* lineTarget = (byte*)dataTarget.Scan0;
bool is32Bpp = sourceBpp == 32;
// scanning through the lines
for (int y = 0; y < dataSource.Height; y++)
// scanning through the pixels within the line
for (int x = 0; x < dataSource.Width; x++)
// testing if pixel is transparent (applies both argb and pargb)
if (is32Bpp && ((uint*)lineSource)[x] >> 24 == 0
|| !is32Bpp && ((ulong*)lineSource)[x] >> 48 == 0UL)
switch (targetBpp)
case 8:
lineTarget[x] = (byte)transparentIndex;
break;
case 4:
// First pixel is the high nibble
int pos = x >> 1;
byte nibbles = lineTarget[pos];
if ((x & 1) == 0)
nibbles &= 0x0F;
nibbles |= (byte)(transparentIndex << 4);
else
nibbles &= 0xF0;
nibbles |= (byte)transparentIndex;
lineTarget[pos] = nibbles;
break;
case 1:
// First pixel is MSB.
pos = x >> 3;
byte mask = (byte)(128 >> (x & 7));
if (transparentIndex == 0)
lineTarget[pos] &= (byte)~mask;
else
lineTarget[pos] |= mask;
break;
lineSource += dataSource.Stride;
lineTarget += dataTarget.Stride;
finally
target.UnlockBits(dataTarget);
source.UnlockBits(dataSource);
private static PixelFormat GetPixelFormat(int bpp)
switch (bpp)
case 1:
return PixelFormat.Format1bppIndexed;
case 4:
return PixelFormat.Format4bppIndexed;
case 8:
return PixelFormat.Format8bppIndexed;
case 16:
return PixelFormat.Format16bppRgb565;
case 24:
return PixelFormat.Format24bppRgb;
case 32:
return PixelFormat.Format32bppArgb;
case 48:
return PixelFormat.Format48bppRgb;
case 64:
return PixelFormat.Format64bppArgb;
default:
throw new ArgumentOutOfRangeException("bpp");
以及原生类型和方法：
private const int BI_RGB = 0;
private const int DIB_RGB_COLORS = 0;
[DllImport("gdi32.dll", CharSet = CharSet.Auto)]
private static extern IntPtr CreateDIBSection(IntPtr hdc, [In] ref BITMAPINFO pbmi, int iUsage, out IntPtr ppvBits, IntPtr hSection, uint dwOffset);
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern IntPtr GetDC(IntPtr hWnd);
[DllImport("gdi32.dll", SetLastError = true)]
private static extern IntPtr SelectObject(IntPtr hdc, IntPtr hgdiobj);
[DllImport("gdi32.dll", SetLastError = true)]
private static extern IntPtr CreateCompatibleDC(IntPtr hdc);
[DllImport("gdi32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool BitBlt(IntPtr hdc, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, uint dwRop);
[DllImport("gdi32.dll")]
private static extern bool DeleteDC(IntPtr hdc);
[DllImport("gdi32.dll", SetLastError = true)]
private static extern bool DeleteObject(IntPtr hObject);
[DllImport("user32.dll")]
private static extern bool ReleaseDC(IntPtr hWnd, IntPtr hDC);
[StructLayout(LayoutKind.Sequential)]
private struct RGBQUAD
internal byte rgbBlue;
internal byte rgbGreen;
internal byte rgbRed;
internal byte rgbReserved;
internal RGBQUAD(Color color)
rgbRed = color.R;
rgbGreen = color.G;
rgbBlue = color.B;
rgbReserved = 0;
[StructLayout(LayoutKind.Sequential)]
private struct BITMAPINFO
public BITMAPINFOHEADER icHeader;
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 256)]
public RGBQUAD[] icColors;
[StructLayout(LayoutKind.Sequential)]
private struct BITMAPINFOHEADER
internal uint biSize;
internal int biWidth;
internal int biHeight;
internal ushort biPlanes;
internal ushort biBitCount;
internal uint biCompression;
internal uint biSizeImage;
internal int biXPelsPerMeter;
internal int biYPelsPerMeter;
internal uint biClrUsed;
internal uint biClrImportant;
更新：
我的Drawing Libraries 现在可以免费下载。它使SaveAsGif 扩展方法在Image 类型上可用：
using KGySoft.Drawing;
/// ...
using (var stream = new FileStream(targetPngPath, FileMode.Create))
// You can either use an arbitrary palette,
myPngBitmap.SaveAsGif(stream, myPngBitmap.GetColors(256));
// or, you can let the built-in encoder use dithering with a fixed palette.
// Pixel format is adjusted so transparency will be preserved.
myPngBitmap.SaveAsGif(stream, allowDithering: true);
【讨论】：
有不安全方法时如何编译？ 见这里：***.com/a/17650474/5114784 如果您不允许在项目中使用不安全的代码，您可以用性能较低的解决方案替换它们。第一个不安全的块可以通过使用GetPixel 方法的回退来避免（非常慢）。而在不安全的方法中，您可以通过Marshal.Copy 将位图内容复制到常规字节数组中。并且在操作byte[]之后，你必须把它复制回来。
只要问一个公共问题并在此处发表评论，以防我错过。但我不能保证有任何帮助。 :)
我目前没有可用资源来做这件事。但是我已经开始实现一些绘图扩展和库，完成后它们将被移动到 GitHub。
仅当您省略 GetColors 的结果时才使用默认调色板。然而，这个GetColors 实现收集了源图像的前 256 种不同颜色（因此是方法上方的 TODO），但如果源实际上有多达 256 种颜色但像素格式是高彩的，这是可以的。
【参考方案2】：
这可能会有所帮助。 Bitmap 类无法正确保存透明度。 您需要将位图转换为图像。
c# Bitmap.Save transparancy doesn't save in png
互联网上有关于 .NET 没有正确保存具有透明度的位图的 cmet。
这里有一个很好的链接供进一步阅读，代码太多了。
http://forums.asp.net/t/1057792.aspx?ASP+NET+C+Making+an+Image+transparent
【讨论】：
以上是关于将透明 PNG 保存为透明 GIF的主要内容，如果未能解决你的问题，请参考以下文章