Windows 10 Powershell，从剪贴板读取图像时透明度信息丢失

Question

我正在尝试使用 Windows 10 Powershell 将具有透明背景的 PNG 图像转换为具有白色背景的不透明图像。

原始源图像是我想复制并粘贴到 Excel 工作表中的网站上的图表，但这里为了演示只使用这个来复制： 526px-Wikipedia-logo-transparent.png

下载图像并在 Powershell 中读取显示：

PS C:\Users\test\Desktop> New-Object System.Drawing.Bitmap("526px-Wikipedia-logo-transparent.png")

Tag                  :
PhysicalDimension    : {Width=526, Height=480}
Size                 : {Width=526, Height=480}
Width                : 526
Height               : 480
HorizontalResolution : 96
VerticalResolution   : 96
Flags                : 73746
RawFormat            : [ImageFormat: b96b3caf-0728-11d3-9d7b-0000f81ef32e]
PixelFormat          : Format32bppArgb
Palette              : System.Drawing.Imaging.ColorPalette
FrameDimensionsList  : {7462dc86-6180-4c7e-8e3f-ee7333a7a483}
PropertyIdList       : {769, 318, 319, 306...}
PropertyItems        : {769, 318, 319, 306...}

PixelFormat明确设置为支持 alpha 通道。

但是，当我只是在浏览器中复制完全相同的图像并从 Powershell 的剪贴板中读取它时，alpha 通道功能就消失了。

PS C:\Users\test\Desktop> Get-Clipboard -Format image

Tag                  :
PhysicalDimension    : {Width=526, Height=480}
Size                 : {Width=526, Height=480}
Width                : 526
Height               : 480
HorizontalResolution : 96
VerticalResolution   : 96
Flags                : 335888
RawFormat            : [ImageFormat: b96b3caa-0728-11d3-9d7b-0000f81ef32e]
PixelFormat          : Format32bppRgb
Palette              : System.Drawing.Imaging.ColorPalette
FrameDimensionsList  : {7462dc86-6180-4c7e-8e3f-ee7333a7a483}
PropertyIdList       : {}
PropertyItems        : {}

更重要的是，在 Paint 3D 中加载图像并将其复制到剪贴板，如果将“透明画布”设置为开或关，则没有任何区别 - Powershell 每次都会在没有透明信息的情况下读取剪贴板。 但是将图像粘贴到 Excel 工作表中时，“透明画布”设置为打开或关闭会有所不同。 因此，剪贴板必须携带此信息，但 Powershell 似乎无法尊重它。

你知道如何让 Powershell 处理带有透明度信息的图像吗？

重要提示：不允许使用第三方工具，解决方案必须使用 Windows 标准工具。

Answer 1

我已经为 Windows PowerShell 5.1 和 PowerShell Core 7+ 采用了此答案中的 C# 解决方案。

我已经包含了原始代码的所有依赖项（分布在多个答案中），因此代码按原样运行。

$refAsm = @(
    'System.Windows.Forms' 
    if( $PSVersionTable.PSVersion.Major -le 5 ) {'System.Drawing'} else { 'System.Drawing.Common', 'System.Drawing.Primitives' }
)
Add-Type -ReferencedAssemblies $refAsm -TypeDefinition @'
using System;
using System.Windows.Forms;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Runtime.InteropServices;

public static class ClipboardImage {
    /// <summary>
    /// Retrieves an image from the given clipboard data object, in the order PNG, DIB, Bitmap, Image object.
    /// </summary>
    /// <param name="retrievedData">The clipboard data.</param>
    /// <returns>The extracted image, or null if no supported image type was found.</returns>
    public static Bitmap GetClipboardImage(DataObject retrievedData)
    {
        Bitmap clipboardimage = null;
        // Order: try PNG, move on to try 32-bit ARGB DIB, then try the normal Bitmap and Image types.
        if (retrievedData.GetDataPresent("PNG", false))
        {
            MemoryStream png_stream = retrievedData.GetData("PNG", false) as MemoryStream;
            if (png_stream != null)
                using (Bitmap bm = new Bitmap(png_stream))
                    clipboardimage = (Bitmap) bm.Clone();
        }
        if (clipboardimage == null && retrievedData.GetDataPresent(DataFormats.Dib, false))
        {
            MemoryStream dib = retrievedData.GetData(DataFormats.Dib, false) as MemoryStream;
            if (dib != null)
                clipboardimage = ImageFromClipboardDib(dib.ToArray());
        }
        if (clipboardimage == null && retrievedData.GetDataPresent(DataFormats.Bitmap))
            clipboardimage = new Bitmap(retrievedData.GetData(DataFormats.Bitmap) as Image);
        if (clipboardimage == null && retrievedData.GetDataPresent(typeof(Image)))
            clipboardimage = new Bitmap(retrievedData.GetData(typeof(Image)) as Image);
        return clipboardimage;
    }

    public static Bitmap ImageFromClipboardDib(Byte[] dibBytes)
    {
        if (dibBytes == null || dibBytes.Length < 4)
            return null;
        try
        {
            Int32 headerSize = (Int32)ReadIntFromByteArray(dibBytes, 0, 4, true);
            // Only supporting 40-byte DIB from clipboard
            if (headerSize != 40)
                return null;
            Byte[] header = new Byte[40];
            Array.Copy(dibBytes, header, 40);
            Int32 imageIndex = headerSize;
            Int32 width = (Int32)ReadIntFromByteArray(header, 0x04, 4, true);
            Int32 height = (Int32)ReadIntFromByteArray(header, 0x08, 4, true);
            Int16 planes = (Int16)ReadIntFromByteArray(header, 0x0C, 2, true);
            Int16 bitCount = (Int16)ReadIntFromByteArray(header, 0x0E, 2, true);
            //Compression: 0 = RGB; 3 = BITFIELDS.
            Int32 compression = (Int32)ReadIntFromByteArray(header, 0x10, 4, true);
            // Not dealing with non-standard formats.
            if (planes != 1 || (compression != 0 && compression != 3))
                return null;
            PixelFormat fmt;
            switch (bitCount)
            {
                case 32:
                    fmt = PixelFormat.Format32bppRgb;
                    break;
                case 24:
                    fmt = PixelFormat.Format24bppRgb;
                    break;
                case 16:
                    fmt = PixelFormat.Format16bppRgb555;
                    break;
                default:
                    return null;
            }
            if (compression == 3)
                imageIndex += 12;
            if (dibBytes.Length < imageIndex)
                return null;
            Byte[] image = new Byte[dibBytes.Length - imageIndex];
            Array.Copy(dibBytes, imageIndex, image, 0, image.Length);
            // Classic stride: fit within blocks of 4 bytes.
            Int32 stride = (((((bitCount * width) + 7) / 8) + 3) / 4) * 4;
            if (compression == 3)
            {
                UInt32 redMask = ReadIntFromByteArray(dibBytes, headerSize + 0, 4, true);
                UInt32 greenMask = ReadIntFromByteArray(dibBytes, headerSize + 4, 4, true);
                UInt32 blueMask = ReadIntFromByteArray(dibBytes, headerSize + 8, 4, true);
                // Fix for the undocumented use of 32bppARGB disguised as BITFIELDS. Despite lacking an alpha bit field,
                // the alpha bytes are still filled in, without any header indication of alpha usage.
                // Pure 32-bit RGB: check if a switch to ARGB can be made by checking for non-zero alpha.
                // Admitted, this may give a mess if the alpha bits simply aren't cleared, but why the hell wouldn't it use 24bpp then?
                if (bitCount == 32 && redMask == 0xFF0000 && greenMask == 0x00FF00 && blueMask == 0x0000FF)
                {
                    // Stride is always a multiple of 4; no need to take it into account for 32bpp.
                    for (Int32 pix = 3; pix < image.Length; pix += 4)
                    {
                        // 0 can mean transparent, but can also mean the alpha isn't filled in, so only check for non-zero alpha,
                        // which would indicate there is actual data in the alpha bytes.
                        if (image[pix] == 0)
                            continue;
                        fmt = PixelFormat.Format32bppPArgb;
                        break;
                    }
                }
                else
                    // Could be supported with a system that parses the colour masks,
                    // but I don't think the clipboard ever uses these anyway.
                    return null;
            }
            Bitmap bitmap = BuildImage(image, width, height, stride, fmt, null, null);
            // This is bmp; reverse image lines.
            bitmap.RotateFlip(RotateFlipType.Rotate180FlipX);
            return bitmap;
        }
        catch
        {
            return null;
        }
    }

    /// <summary>
    /// Creates a bitmap based on data, width, height, stride and pixel format.
    /// </summary>
    /// <param name="sourceData">Byte array of raw source data</param>
    /// <param name="width">Width of the image</param>
    /// <param name="height">Height of the image</param>
    /// <param name="stride">Scanline length inside the data</param>
    /// <param name="pixelFormat">Pixel format</param>
    /// <param name="palette">Color palette</param>
    /// <param name="defaultColor">Default color to fill in on the palette if the given colors don't fully fill it.</param>
    /// <returns>The new image</returns>
    public static Bitmap BuildImage(Byte[] sourceData, Int32 width, Int32 height, Int32 stride, PixelFormat pixelFormat, Color[] palette, Color? defaultColor)
    {
        Bitmap newImage = new Bitmap(width, height, pixelFormat);
        BitmapData targetData = newImage.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.WriteOnly, newImage.PixelFormat);
        Int32 newDataWidth = ((Image.GetPixelFormatSize(pixelFormat) * width) + 7) / 8;
        // Compensate for possible negative stride on BMP format.
        Boolean isFlipped = stride < 0;
        stride = Math.Abs(stride);
        // Cache these to avoid unnecessary getter calls.
        Int32 targetStride = targetData.Stride;
        Int64 scan0 = targetData.Scan0.ToInt64();
        for (Int32 y = 0; y < height; y++)
            Marshal.Copy(sourceData, y * stride, new IntPtr(scan0 + y * targetStride), newDataWidth);
        newImage.UnlockBits(targetData);
        // Fix negative stride on BMP format.
        if (isFlipped)
            newImage.RotateFlip(RotateFlipType.Rotate180FlipX);
        // For indexed images, set the palette.
        if ((pixelFormat & PixelFormat.Indexed) != 0 && palette != null)
        {
            ColorPalette pal = newImage.Palette;
            for (Int32 i = 0; i < pal.Entries.Length; i++)
            {
                if (i < palette.Length)
                    pal.Entries[i] = palette[i];
                else if (defaultColor.HasValue)
                    pal.Entries[i] = defaultColor.Value;
                else
                    break;
            }
            newImage.Palette = pal;
        }
        return newImage;
    }    

    static void WriteIntToByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian, UInt32 value)
    {
        Int32 lastByte = bytes - 1;
        if (data.Length < startIndex + bytes)
            throw new ArgumentOutOfRangeException("startIndex", "Data array is too small to write a " + bytes + "-byte value at offset " + startIndex + ".");
        for (Int32 index = 0; index < bytes; index++)
        {
            Int32 offs = startIndex + (littleEndian ? index : lastByte - index);
            data[offs] = (Byte)(value >> (8 * index) & 0xFF);
        }
    }
    
    static UInt32 ReadIntFromByteArray(Byte[] data, Int32 startIndex, Int32 bytes, Boolean littleEndian)
    {
        Int32 lastByte = bytes - 1;
        if (data.Length < startIndex + bytes)
            throw new ArgumentOutOfRangeException("startIndex", "Data array is too small to read a " + bytes + "-byte value at offset " + startIndex + ".");
        UInt32 value = 0;
        for (Int32 index = 0; index < bytes; index++)
        {
            Int32 offs = startIndex + (littleEndian ? index : lastByte - index);
            value += (UInt32)(data[offs] << (8 * index));
        }
        return value;
    }    
}
'@

使用示例：

Add-Type -Assembly System.Windows.Forms

$data  = [System.Windows.Forms.Clipboard]::GetDataObject()
$image = [ClipboardImage]::GetClipboardImage( $data )
$image.Save("$PWD\clipboard.png")