我正在尝试自学C#，听说get和setpixel函数非常慢。有什么替代方法，性能提升真的那么显著吗？
以下是我的一段代码：
public static Bitmap Paint(Bitmap _b, Color f)
{
Bitmap b = new Bitmap(_b);
for (int x = 0; x < b.Width; x++)
{
for (int y = 0; y < b.Height; y++)
{
Color c = b.GetPixel(x, y);
b.SetPixel(x, y, Color.FromArgb(c.A, f.R, f.G, f.B));
}
}
return b;
}
public class DirectBitmap : IDisposable
{
public Bitmap Bitmap { get; private set; }
public Int32[] Bits { get; private set; }
public bool Disposed { get; private set; }
public int Height { get; private set; }
public int Width { get; private set; }
protected GCHandle BitsHandle { get; private set; }
public DirectBitmap(int width, int height)
{
Width = width;
Height = height;
Bits = new Int32[width * height];
BitsHandle = GCHandle.Alloc(Bits, GCHandleType.Pinned);
Bitmap = new Bitmap(width, height, width * 4, PixelFormat.Format32bppPArgb, BitsHandle.AddrOfPinnedObject());
}
public void SetPixel(int x, int y, Color colour)
{
int index = x + (y * Width);
int col = colour.ToArgb();
Bits[index] = col;
}
public Color GetPixel(int x, int y)
{
int index = x + (y * Width);
int col = Bits[index];
Color result = Color.FromArgb(col);
return result;
}
public void Dispose()
{
if (Disposed) return;
Disposed = true;
Bitmap.Dispose();
BitsHandle.Free();
}
}
不需要使用LockBits或SetPixel。使用上述类来直接访问位图数据。
使用此类，可以将原始位图数据设置为32位数据。请注意，它是PARGB，即预乘 alpha。有关如何工作的更多信息，请参见维基百科上的 Alpha Compositing，以及MSDN文章中有关 BLENDFUNCTION 的示例以了解如何正确计算 alpha。
如果预乘可能会使事情过于复杂，请改用PixelFormat.Format32bppArgb。当其被绘制时会出现性能损失，因为它在内部被转换为PixelFormat.Format32bppPArgb。如果在绘制之前图像不必更改，则可以在预乘之前完成工作，将其绘制到PixelFormat.Format32bppArgb缓冲区中，并从那里进一步使用。
通过Bitmap属性可以访问标准的Bitmap成员。使用Bits属性可以直接访问位图数据。
byte而不是int来处理原始像素数据将两个实例中的Int32都改为byte，然后更改此行：
Bits = new Int32[width * height];
变成这样：
Bits = new byte[width * height * 4];
使用字节时，格式为Alpha / Red / Green / Blue。每个像素需要4个字节的数据，分别为每个通道一个字节。 GetPixel和SetPixel函数需要相应地重新设计或删除。
Bitmap一样实现了IDisposable。unsafe 块。Graphics对象访问因为Bitmap属性实际上是.NETBitmap对象，所以可以使用Graphics类执行操作。
var dbm = new DirectBitmap(200, 200);
using (var g = Graphics.FromImage(dbm.Bitmap))
{
g.DrawRectangle(Pens.Black, new Rectangle(50, 50, 100, 100));
}
这个问题涉及到性能，以下是一张表格，展示了三种不同方法在相对性能方面的比较。该测试使用基于 .NET Standard 2 和 NUnit 的应用程序进行。
* Time to fill the entire bitmap with red pixels *
- Not including the time to create and dispose the bitmap
- Best out of 100 runs taken
- Lower is better
- Time is measured in Stopwatch ticks to emphasize magnitude rather than actual time elapsed
- Tests were performed on an Intel Core i7-4790 based workstation
Bitmap size
Method 4x4 16x16 64x64 256x256 1024x1024 4096x4096
DirectBitmap <1 2 28 668 8219 178639
LockBits 2 3 33 670 9612 197115
SetPixel 45 371 5920 97477 1563171 25811013
* Test details *
- LockBits test: Bitmap.LockBits is only called once and the benchmark
includes Bitmap.UnlockBits. It is expected that this
is the absolute best case, adding more lock/unlock calls
will increase the time required to complete the operation.
~DirectBitmap（）终结方法中调用Dispose（），或提供一个示例用法，在using（DirectBitmap bmp = new DirectBitmap（））{...}块中创建DirectBitmap。 - Gladclef在C#中，位图操作速度缓慢的原因在于锁定和解锁。每次操作都需要对所需位进行锁定，操作这些位，然后再解锁这些位。
通过自己处理这些操作，可以大大提高速度。请参考以下示例。
using (var tile = new Bitmap(tilePart.Width, tilePart.Height))
{
try
{
BitmapData srcData = sourceImage.LockBits(tilePart, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
BitmapData dstData = tile.LockBits(new Rectangle(0, 0, tile.Width, tile.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
unsafe
{
byte* dstPointer = (byte*)dstData.Scan0;
byte* srcPointer = (byte*)srcData.Scan0;
for (int i = 0; i < tilePart.Height; i++)
{
for (int j = 0; j < tilePart.Width; j++)
{
dstPointer[0] = srcPointer[0]; // Blue
dstPointer[1] = srcPointer[1]; // Green
dstPointer[2] = srcPointer[2]; // Red
dstPointer[3] = srcPointer[3]; // Alpha
srcPointer += BytesPerPixel;
dstPointer += BytesPerPixel;
}
srcPointer += srcStrideOffset + srcTileOffset;
dstPointer += dstStrideOffset;
}
}
tile.UnlockBits(dstData);
aSourceImage.UnlockBits(srcData);
tile.Save(path);
}
catch (InvalidOperationException e)
{
}
}
tilePart.Width 和 tilePart.Height 很慢。考虑将它们的结果放入单独的宽度/高度变量中。在我这个情况下，这样做可以将性能提升40倍，对于2048x2048像素的图像也是如此。 - blade已经过了一段时间，但我找到了一个可能有用的例子。
var btm = new Bitmap("image.png");
BitmapData btmDt = btm.LockBits(
new Rectangle(0, 0, btm.Width, btm.Height),
ImageLockMode.ReadWrite,
btm.PixelFormat
);
IntPtr pointer = btmDt.Scan0;
int size = Math.Abs(btmDt.Stride) * btm.Height;
byte[] pixels = new byte[size];
Marshal.Copy(pointer, pixels, 0, size);
for (int b = 0; b < pixels.Length; b++)
{
pixels[b] = 255; //Do something here
}
Marshal.Copy(pixels, 0, pointer, size);
btm.UnlockBits(btmDt);
这段代码应该并行化，同步运行会导致巨大的性能损失。几乎所有现代微芯片都至少有4个可用线程，而一些芯片则有40个可用线程。
没有任何理由让第一个循环同步运行。你可以使用许多线程遍历宽度或长度。
private void TakeApart_Fast(Bitmap processedBitmap)
{
BitmapData bitmapData = processedBitmap.LockBits(new Rectangle(0, 0, processedBitmap.Width, processedBitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
ConcurrentBag<byte> points = new ConcurrentBag<byte>();
unsafe
{
int bytesPerPixel = System.Drawing.Bitmap.GetPixelFormatSize(processedBitmap.PixelFormat) / 8;
int heightInPixels = bitmapData.Height;
int widthInBytes = bitmapData.Width * bytesPerPixel;
_RedMin = byte.MaxValue;
_RedMax = byte.MinValue;
byte* PtrFirstPixel = (byte*)bitmapData.Scan0;
Parallel.For(0, heightInPixels, y =>
{
byte* currentLine = PtrFirstPixel + (y * bitmapData.Stride);
for (int x = 0; x < widthInBytes; x = x + bytesPerPixel)
{
// red
byte redPixel = currentLine[x + 2];
//save information with the concurrentbag
}
});
processedBitmap.UnlockBits(bitmapData);
}
}`
基准测试并不意味着太多，因为这将加速处理的程度取决于您使用的硬件以及后台运行的其他内容，这完全取决于有多少可用的空闲线程。如果您在4000系列图形卡上运行此程序，并且拥有数千个流处理器，则可以同时迭代图像的每一列。
如果您在旧的四核处理器上运行它，则可能只有5或6个线程，但仍然非常显著。
您可以使用Bitmap.LockBits方法。如果您想要使用并行任务执行，可以使用System.Threading.Tasks命名空间中的Parallel类。以下链接提供了一些示例和解释。