Թույլ տալ, որ Պատկերը հասանելի լինի մի քանի շղթաներով

Օգտագործելով LockBits (որը Նաև շատ ավելի արագ է, քան GetPixel & SetPixel-ը), դուք կարող եք պատճենել պատկերի պիքսելները բուֆերում, զուգահեռ թելեր անցկացնել դրա վրա և այնուհետև պատճենել բուֆերը:

Ահա աշխատանքային օրինակ.

void Test()
{
    string inputFile = @"e:\temp\a.jpg";
    string outputFile = @"e:\temp\b.jpg";

    Bitmap bmp = Bitmap.FromFile(inputFile) as Bitmap;

    var rect = new Rectangle(0, 0, bmp.Width, bmp.Height);
    var data = bmp.LockBits(rect, ImageLockMode.ReadWrite, bmp.PixelFormat);
    var depth = Bitmap.GetPixelFormatSize(data.PixelFormat) / 8; //bytes per pixel

    var buffer = new byte[data.Width * data.Height * depth];

    //copy pixels to buffer
    Marshal.Copy(data.Scan0, buffer, 0, buffer.Length);

    Parallel.Invoke(
        () => {
            //upper-left
            Process(buffer, 0, 0, data.Width / 2, data.Height / 2, data.Width, depth);
        },
        () => {
            //lower-right
            Process(buffer, data.Width / 2, data.Height / 2, data.Width, data.Height, data.Width, depth);
        }
    );

    //Copy the buffer back to image
    Marshal.Copy(buffer, 0, data.Scan0, buffer.Length);

    bmp.UnlockBits(data);

    bmp.Save(outputFile, ImageFormat.Jpeg);
}

void Process(byte[] buffer, int x, int y, int endx, int endy, int width, int depth)
{
    for (int i = x; i < endx; i++)
    {
        for (int j = y; j < endy; j++)
        {
            var offset = ((j * width) + i) * depth;
            // Dummy work    
            // To grayscale (0.2126 R + 0.7152 G + 0.0722 B)
            var b = 0.2126 * buffer[offset + 0] + 0.7152 * buffer[offset + 1] + 0.0722 * buffer[offset + 2];
            buffer[offset + 0] = buffer[offset + 1] = buffer[offset + 2] = (byte)b;
        }
    }
}

Մուտքագրեք պատկեր՝

Ելքային պատկեր՝

Մի քանի կոպիտ թեստեր.

(41 մեգապիքսել, [7152x5368]) պատկերի փոխակերպում մոխրագույն մասշտաբի երկմիջուկային 2,1 ԳՀց սարքի վրա

• GetPixel/SetPixel - Single Core - 131 վրկ.
• LockBits - Single Core - 4,5 վրկ.
• LockBits - Dual Core - 3 վրկ.

Մեկ այլ լուծում կլինի ժամանակավոր կոնտեյների ստեղծումը Bitmap-ի մասին տեղեկություններով, ինչպիսիք են լայնությունը, բարձրությունը, քայլը, բուֆերը և պիքսելային ձևաչափը: Երբ դուք պետք է զուգահեռ մուտք գործեք Bitmap, պարզապես ստեղծեք այն՝ հիմնվելով ժամանակավոր կոնտեյների տեղեկատվության վրա:

Դրա համար մեզ անհրաժեշտ է ընդլայնման մեթոդ՝ Bitmap-ի բուֆերն ու քայլը ստանալու համար:

public static Tuple<IntPtr, int> ToBufferAndStride(this Bitmap bitmap)
{
    BitmapData bitmapData = null;

    try
    {
        bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), 
            ImageLockMode.ReadOnly, bitmap.PixelFormat);

        return new Tuple<IntPtr, int>(bitmapData.Scan0, bitmapData.Stride);
    }
    finally
    {
        if (bitmapData != null)
            bitmap.UnlockBits(bitmapData);
    }
}

Այս երկարացման մեթոդը կօգտագործվի ժամանակավոր կոնտեյների ներսում.

public class BitmapContainer
{
    public PixelFormat Format { get; }

    public int Width { get; }

    public int Height { get; }

    public IntPtr Buffer { get; }

    public int Stride { get; set; }

    public BitmapContainer(Bitmap bitmap)
    {
        if (bitmap == null)
            throw new ArgumentNullException(nameof(bitmap));

        Format = bitmap.PixelFormat;
        Width = bitmap.Width;
        Height = bitmap.Height;

        var bufferAndStride = bitmap.ToBufferAndStride();
        Buffer = bufferAndStride.Item1;
        Stride = bufferAndStride.Item2;
    }

    public Bitmap ToBitmap()
    {
        return new Bitmap(Width, Height, Stride, Format, Buffer);
    }
}

Այժմ դուք կարող եք օգտագործել BitmapContainer-ը զուգահեռաբար կատարվող մեթոդում.

BitmapContainer container = new BitmapContainer(bitmap);

Parallel.For(0, 10, i =>
{
    Bitmap parallelBitmap = container.ToBitmap();
    // ...
});