Определить, используется ли Альфа-канал в изображении
когда я вношу изображения в свою программу, я хочу определить, если:
- у них есть альфа-канал
- если этот альфа-канал используется
#1 достаточно просто с помощью Image.IsAlphaPixelFormat. Для #2 хотя, кроме цикла через каждый пиксель, есть ли простой способ определить, имеет ли хотя бы один из пикселей альфа-канал, который используется (т. е. установлено какое-то другое значение, чем 255)? Все Я need back-это логическое значение, а затем я определю, следует ли сохранить его в 32-бит или 24-бит.
обновление: я обнаружил, что ImageFlags.HasTranslucent должен предоставить мне то, что я ищу - к сожалению, это не работает вообще. Например, PNGs с форматами пикселей, которые имеют по крайней мере альфа-канал 66 (полупрозрачный) продолжают сообщать False (использование: if((img.Flags & ImageFlags.HasTranslucent) == 4) ...;). Я протестировал все типы изображений, в том числе .БМП, что имейте Альфа-значение >0 и False. Кто-нибудь когда-либо использовал это и знает, работает ли он в GDI+?
4 ответов
вам не придется перебрать каждый пиксель (ну вы можете, но это зависит от изображения). Настройте цикл на все пиксели, но просто вырвитесь из цикла, когда вы найдете Альфа-значение, отличное от 255, используйте следующий псевдо-код:
bool hasAlpha = false;
foreach (var pixel in image)
{
hasAlpha = pixel.Alpha != 255;
if (hasAlpha)
{
break;
}
}
вам нужно будет только проверить все пиксели для изображений, у которых нет Альфы. Для изображений, у которых есть альфа, это произойдет довольно быстро.
Я получаю более продвинутое решение, основанное на ответе ChrisF:
public bool IsImageTransparent(Bitmap image,string optionalBgColorGhost)
{
for (int i = 0; i < image.Width; i++)
{
for (int j = 0; j < image.Height; j++)
{
var pixel = image.GetPixel(i, j);
if (pixel.A != 255)
return true;
}
}
//Check 4 corners to check if all of them are with the same color!
if (!string.IsNullOrEmpty(optionalBgColorGhost))
{
if (image.GetPixel(0, 0).ToArgb() == GetColorFromString(optionalBgColorGhost).ToArgb())
{
if (image.GetPixel(image.Width - 1, 0).ToArgb() == GetColorFromString(optionalBgColorGhost).ToArgb())
{
if (image.GetPixel(0, image.Height - 1).ToArgb() ==
GetColorFromString(optionalBgColorGhost).ToArgb())
{
if (image.GetPixel(image.Width - 1, image.Height - 1).ToArgb() ==
GetColorFromString(optionalBgColorGhost).ToArgb())
{
return true;
}
}
}
}
}
return false;
}
public static Color GetColorFromString(string colorHex)
{
return ColorTranslator.FromHtml(colorHex);
}
Он имеет необязательную цветовую строку bg для непрозрачных изображений:
пример использования:
IsImageTransparent(new Bitmap(myImg),"#FFFFFF");
вы не найдете лучшего решения, чем это, мне потребовалось несколько часов, чтобы оптимизировать:
public bool IsAlphaBitmap(ref System.Drawing.Imaging.BitmapData BmpData)
{
byte[] Bytes = new byte[BmpData.Height * BmpData.Stride];
Marshal.Copy(BmpData.Scan0, Bytes, 0, Bytes.Length);
for (p = 3; p < Bytes.Length; p += 4) {
if (Bytes[p] != 255) return true;
}
return false;
}
объединение нескольких методов для разных типов изображений дало мне этот окончательный метод, который, похоже, делает хорошую работу для любого изображения, которое вы сбрасываете в него, будь то потенциально прозрачный gif или png, содержащий альфа-канал. Благодаря ответу Elmo для быстрого метода чтения байтов.
боковое Примечание: do не использовать Image.IsAlphaPixelFormat(bitmap.PixelFormat)); он видит paletted форматы как не-альфа-способные, в то время как такие изображения can фактически обладают прозрачностью. Только не "альфа". Однако такие 8-битные изображения с поддержкой прозрачности имеют флаг HasAlpha, поэтому это все еще полезная проверка.
public static Boolean HasTransparency(Bitmap bitmap)
{
// not an alpha-capable color format.
if ((bitmap.Flags & (Int32)ImageFlags.HasAlpha) == 0)
return false;
// Indexed formats. Special case because one index on their palette is configured as THE transparent color.
if (bitmap.PixelFormat == PixelFormat.Format8bppIndexed || bitmap.PixelFormat == PixelFormat.Format4bppIndexed)
{
ColorPalette pal = bitmap.Palette;
// Find the transparent index on the palette.
Int32 transCol = -1;
for (int i = 0; i < pal.Entries.Length; i++)
{
Color col = pal.Entries[i];
if (col.A != 255)
{
// Color palettes should only have one index acting as transparency. Not sure if there's a better way of getting it...
transCol = i;
break;
}
}
// none of the entries in the palette have transparency information.
if (transCol == -1)
return false;
// Check pixels for existence of the transparent index.
Int32 colDepth = Image.GetPixelFormatSize(bitmap.PixelFormat);
BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
Int32 stride = data.Stride;
Byte[] bytes = new Byte[bitmap.Height * stride];
Marshal.Copy(data.Scan0, bytes, 0, bytes.Length);
bitmap.UnlockBits(data);
if (colDepth == 8)
{
// Last line index.
Int32 lineMax = bitmap.Width - 1;
for (Int32 i = 0; i < bytes.Length; i++)
{
// Last position to process.
Int32 linepos = i % stride;
// Passed last image byte of the line. Abort and go on with loop.
if (linepos > lineMax)
continue;
Byte b = bytes[i];
if (b == transCol)
return true;
}
}
else if (colDepth == 4)
{
// line size in bytes. 1-indexed for the moment.
Int32 lineMax = bitmap.Width / 2;
// Check if end of line ends on half a byte.
Boolean halfByte = bitmap.Width % 2 != 0;
// If it ends on half a byte, one more needs to be processed.
// We subtract in the other case instead, to make it 0-indexed right away.
if (!halfByte)
lineMax--;
for (Int32 i = 0; i < bytes.Length; i++)
{
// Last position to process.
Int32 linepos = i % stride;
// Passed last image byte of the line. Abort and go on with loop.
if (linepos > lineMax)
continue;
Byte b = bytes[i];
if ((b & 0x0F) == transCol)
return true;
if (halfByte && linepos == lineMax) // reached last byte of the line. If only half a byte to check on that, abort and go on with loop.
continue;
if (((b & 0xF0) >> 4) == transCol)
return true;
}
}
return false;
}
if (bitmap.PixelFormat == PixelFormat.Format32bppArgb || bitmap.PixelFormat == PixelFormat.Format32bppPArgb)
{
BitmapData data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
Byte[] bytes = new Byte[bitmap.Height * data.Stride];
Marshal.Copy(data.Scan0, bytes, 0, bytes.Length);
bitmap.UnlockBits(data);
for (Int32 p = 3; p < bytes.Length; p += 4)
{
if (bytes[p] != 255)
return true;
}
return false;
}
// Final "screw it all" method. This is pretty slow, but it won't ever be used, unless you
// encounter some really esoteric types not handled above, like 16bppArgb1555 and 64bppArgb.
for (Int32 i = 0; i < bitmap.Width; i++)
{
for (Int32 j = 0; j < bitmap.Height; j++)
{
if (bitmap.GetPixel(i, j).A != 255)
return true;
}
}
return false;
}