Fast Pixel Operations in .NET (With and Without unsafe)

最新推荐文章于 2021-07-27 11:28:52 发布
最新推荐文章于 2021-07-27 11:28:52 发布
阅读量3.2k 收藏
点赞数
分类专栏： C# Bitmap 文章标签： .net methods bitmap unsafe lockBi
C# 同时被 2 个专栏收录
1 篇文章 0 订阅
订阅专栏
Bitmap
1 篇文章 0 订阅
订阅专栏
Using GetPixel or SetPixel for all but tiniest images is a terrible idea. Stop using these methods and make your code over 300 times faster!

Introduction

The Bitmap class has GetPixel and SetPixel methods that let you acquire and change color of chosen pixels. Those methods are very easy to use but are also extremely slow. My previous post gives detailed explanation on the topic, click here if you are interested.

Fortunately, you don’t have to use external libraries (or resign from .NET altogether) to do fast image manipulation. The Framework contains a class called ColorMatrix that lets you apply many changes to images in an efficient manner. Properties such as contrast or saturation can be modified this way. But what about manipulation of individual pixels? It can be done too, with the help from the Bitmap.LockBits method and the BitmapData class…

A good way to test individual pixel manipulation speed is color difference detection. The task is to find portions of an image that have color similar to some chosen color. How to check if colors are similar? Think about color as a point in three dimensional space, where axis are: red, green and blue. Two colors are two points. The difference between colors is described by the distance between two points in RGB space.

Colors as points in 3D spacediff = sqrt((C1R-C2R)2+(C1G-C2G)2+(C1B-C2B)2)

This technique is very easy to implement and gives decent results. Color comparison is actually a pretty complex matter though. Different color spaces are better suited for the task than RGB and human color perception should be taken into account (e.g. our eyes are more keen to detect difference in shades of green that in shades of blue). But let’s keep things simple here…

Our test image will be this Ultra HD 8K (7680x4320, 33.1Mpx) picture* (on this blog, it’s of course scaled down to save bandwidth): 

Color difference detection input image (scaled down for blog)

This is a method that may be used to look for R=253 G=129 B=84 pixels (aka “pink bra”). It sets matching pixels as white (the rest will be black): 


static void DetectColorWithGetSetPixel(Bitmap image, 
  byte searchedR, byte searchedG, int searchedB, int tolerance)
{
    int toleranceSquared = tolerance * tolerance;

    for (int x = 0; x < image.Width; x++)
    {
        for (int y = 0; y < image.Height; y++)
        {
            Color pixel = image.GetPixel(x, y);

            int diffR = pixel.R - searchedR;
            int diffG = pixel.G - searchedG;
            int diffB = pixel.B - searchedB;

            int distance = diffR * diffR + diffG * diffG + diffB * diffB;

            image.SetPixel(x, y, distance > toleranceSquared ? Color.Black : Color.White);
        }
    }
}

The above code is our terribly slow Get/SetPixel baseline. If we call it this way (named parameters for clarity):

DetectColorWithGetSetPixel(image, searchedR: 253, searchedG: 129, searchedB: 255, tolerance: 84);

we will receive the following outcome: 

Color difference detection output image (scaled down)

Result may be ok but having to wait over 84300ms* is a complete disaster! 

Now check out this method: 

static unsafe void DetectColorWithUnsafe(Bitmap image, 
  byte searchedR, byte searchedG, int searchedB, int tolerance)
{
    BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, 
      image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    int bytesPerPixel = 3;

    byte* scan0 = (byte*)imageData.Scan0.ToPointer();
    int stride = imageData.Stride;

    byte unmatchingValue = 0;
    byte matchingValue = 255;
    int toleranceSquared = tolerance * tolerance;

    for (int y = 0; y < imageData.Height; y++)
    {
        byte* row = scan0 + (y * stride);

        for (int x = 0; x < imageData.Width; x++)
        {
            // Watch out for actual order (BGR)!
            int bIndex = x * bytesPerPixel;
            int gIndex = bIndex + 1;
            int rIndex = bIndex + 2;

            byte pixelR = row[rIndex];
            byte pixelG = row[gIndex];
            byte pixelB = row[bIndex];

            int diffR = pixelR - searchedR;
            int diffG = pixelG - searchedG;
            int diffB = pixelB - searchedB;

            int distance = diffR * diffR + diffG * diffG + diffB * diffB;

            row[rIndex] = row[bIndex] = row[gIndex] = distance > 
              toleranceSquared ? unmatchingValue : matchingValue;
        }
    }

    image.UnlockBits(imageData);
}


It does exactly the same thing but runs for only 230ms - over 360 times faster!

The above code makes use of Bitmap.LockBits method that is a wrapper for native GdipBitmapLockBits(GDI+, gdiplus.dll) function. LockBits creates a temporary buffer that contains pixel information in desired format (in our case RGB, 8 bits per color component). Any changes to this buffer are copied back to the bitmap upon UnlockBits call (therefore, you should always use LockBits and UnlockBits as a pair). Bitmap.LockBits returns BitmapData object (System.Drawing.Imaging namespace) that has two interesting properties: Scan0 and Stride. Scan0 returns an address of the first pixel data. Stride is the width of single row of pixels (scan line) in bytes (with optional padding to make it dividable by 4). 

BitmapData layout

Please notice that I don’t use calls to Math.Pow and Math.Sqrt to calculate distance between colors. Writing code like this: 

double distance = Math.Sqrt(Math.Pow(pixelR - searchedR, 2) + 
Math.Pow(pixelG - searchedG, 2) + Math.Pow(pixelB - searchedB, 2));

to process millions of pixels is a terrible idea. Such line can make our optimized method about 25 times slower! Using Math.Pow with integer parameters is extremely wasteful and we don’t have to calculate square root to determine if distance is longer than specified tolerance.

Previously presented method uses code marked with unsafe keyword. It allows C# program to take advantage of pointer arithmetic. Unfortunately, unsafe mode has some important restrictions. Code must be compiled with \unsafe option and executed for fully trusted assembly. 

Luckily, there is a Marshal.Copy method (from System.Runtime.InteropServices namespace) that can move data between managed and unmanaged memory. We can use it to copy image data into a byte array and manipulate pixels very efficiently. Look at this method: 

static void DetectColorWithMarshal(Bitmap image, 
  byte searchedR, byte searchedG, int searchedB, int tolerance)
{        
    BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, 
      image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);

    byte[] imageBytes = new byte[Math.Abs(imageData.Stride) * image.Height];
    IntPtr scan0 = imageData.Scan0;

    Marshal.Copy(scan0, imageBytes, 0, imageBytes.Length);
  
    byte unmatchingValue = 0;
    byte matchingValue = 255;
    int toleranceSquared = tolerance * tolerance;

    for (int i = 0; i < imageBytes.Length; i += 3)
    {
        byte pixelB = imageBytes[i];
        byte pixelR = imageBytes[i + 2];
        byte pixelG = imageBytes[i + 1];

        int diffR = pixelR - searchedR;
        int diffG = pixelG - searchedG;
        int diffB = pixelB - searchedB;

        int distance = diffR * diffR + diffG * diffG + diffB * diffB;

        imageBytes[i] = imageBytes[i + 1] = imageBytes[i + 2] = distance > 
          toleranceSquared ? unmatchingValue : matchingValue;
    }

    Marshal.Copy(imageBytes, 0, scan0, imageBytes.Length);

    image.UnlockBits(imageData);
}


It runs for 280ms, so it is only slightly slower than unsafe version. It is CPU efficient but uses more memorythan the previous method – almost 100 megabytes for our test Ultra HD 8K image in RGB 24 format.

If you want to make pixel manipulation even faster, you may process different parts of the image in parallel. You need to make some benchmarking first because for small images, the cost of threading may be bigger than gains from concurrent execution. Here’s a quick sample of code that uses 4 threads to process 4 parts of the image simultaneously. It yields 30% time improvement on my machine. Treat is as a quick and dirty hint, this post is already too long… 

static unsafe void DetectColorWithUnsafeParallel(Bitmap image, 
    byte searchedR, byte searchedG, int searchedB, int tolerance)
{
    BitmapData imageData = image.LockBits(new Rectangle(0, 0, image.Width, 
      image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
    int bytesPerPixel = 3;

    byte* scan0 = (byte*)imageData.Scan0.ToPointer();
    int stride = imageData.Stride;

    byte unmatchingValue = 0;
    byte matchingValue = 255;
    int toleranceSquared = tolerance * tolerance;

    Task[] tasks = new Task[4];
    for (int i = 0; i < tasks.Length; i++)
    {
        int ii = i;
        tasks[i] = Task.Factory.StartNew(() =>
            {
                int minY = ii < 2 ? 0 : imageData.Height / 2;
                int maxY = ii < 2 ? imageData.Height / 2 : imageData.Height;

                int minX = ii % 2 == 0 ? 0 : imageData.Width / 2;
                int maxX = ii % 2 == 0 ? imageData.Width / 2 : imageData.Width;                        
                
                for (int y = minY; y < maxY; y++)
                {
                    byte* row = scan0 + (y * stride);

                    for (int x = minX; x < maxX; x++)
                    {
                        int bIndex = x * bytesPerPixel;
                        int gIndex = bIndex + 1;
                        int rIndex = bIndex + 2;

                        byte pixelR = row[rIndex];
                        byte pixelG = row[gIndex];
                        byte pixelB = row[bIndex];

                        int diffR = pixelR - searchedR;
                        int diffG = pixelG - searchedG;
                        int diffB = pixelB - searchedB;

                        int distance = diffR * diffR + diffG * diffG + diffB * diffB;

                        row[rIndex] = row[bIndex] = row[gIndex] = distance >
                            toleranceSquared ? unmatchingValue : matchingValue;
                    }
                }
            });
    }

    Task.WaitAll(tasks);

    image.UnlockBits(imageData);
}


* Originally I had some triangles and squares as an illustration, but Victoria's Secret models (source) are better, huh? Smile | :)

* .NET 4 console app, executed on MSI GE620 DX laptop: Intel Core i5-2430M 2.40GHz (2 cores, 4 threads), 4GB DDR3 RAM, NVIDIA GT 555M 2GB DDR3, HDD 500GB 7200RPM, Windows 7 Home Premium x64.

Update (13.07.2013): I forgot to precalculate tolerance * tolerance (thanks to Axel Rietschin for noticing this). With toleranceSquared, DetectColorWithUnsafe execution time dropped from 260ms to 230ms. 


MichaelChansn
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
golang type assertion and unsafe.Pointer 性能对比
01-07
golang type assertion and unsafe.Pointer 性能对比 最近项目中有这样一个需求背景：有一个存储实体用来做各种指标的counter。这个counter的实现需要能够在以后被别的实现替换。结构自然是这样： type XXXObj ...
20130901可注册域名列表
热门推荐
落寞红尘
09-02 13万+
aeppv.com affjv.com afiun.com agthh.com ahmsp.com aixhr.com ajvcd.com aLoae.com ambLu.com anabL.com andwu.com anszL.com aoehq.com aoLdo.com apcnn.com aphcr.com apkoi.com aprty.com ar
2020-11-26
smallITAA的博客
11-26 1353
table 序号 姓名 存款 私房钱 合计 操作 1 zs 5000.0 2.3 50.0 行添加 | 行删除 2 ls 12378.5 ...
push参数
lvlemo的博客
11-20 8765
this.$router.push({ name:'forgetCodeTwoModule', params:{ result:response } }) {{this.$route.params.resu
apns详细过程
freezing_yu的专栏
11-15 1483
https://developer.apple.com/library/ios/#documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/IPhoneOSClientImp/IPhoneOSClientImp.html#//apple_ref/doc/uid/TP40008194-CH103-SW1     在项目的
2020-12-22
weixin_44999141的博客
12-22 2448
C#发送电子邮件 用到的命名空间 using System.Net.Mail; 下面贴代码： /// /// 发送邮件 /// /// 收件人(多个电子邮件地址之间必须用逗号字符（“,”）分隔) /// 标题 /// 内容 /// 内嵌图片 /// 附件路径 public bool SendMessage(string sendToList, string subject, string body, string inLineImage, string attachmentsPath) { string
golang unsafe 和 uintptr 指针
01-20
在Go语言中，`unsafe`包提供了一种特殊的方式来打破语言的类型系统，允许程序员进行低级别的内存操作。本文将详细探讨`unsafe`包中的`unsafe.Pointer`和`uintptr`指针类型，以及它们在Go语言中的应用。 1. **Golang...
unsafe:使用sun.misc.Unsafe的各种Java类
05-23
unsafe-helper-包含一些简单的方法，这些方法使使用sun.misc.Unsafe更容易。 unsafe-collection-在ArrayList上建模的示例列表，该列表不存储对集合内对象的引用，而是直接将元素复制到列表中。 这有一些有趣的特性...
Study on Influencing Factors and the Model of Unsafe Behaviors in Coal Mines Based on DEMATEL and ISM
01-15
基于DEMATEL和ISM方法的煤矿不安全行为影响因素及模式研究，李爽，吴雪，煤矿生产中，在机器设计和布置合理的情况下，控制人的不安全行为显得尤为重要。不安全行为的发生是诸多因素相互作用的结果，本文
Java中unsafe操作实例总结
08-27
Unsafe类提供了多种操作，包括compareAndSwap、putOrder等，以下是对Unsafe操作的详细介绍。 compareAndSwap操作 compareAndSwap操作是Unsafe类中最重要的操作之一，它可以实现原子操作，保证了多线程环境下的线程...
pushd命令
weixin_34337381的博客
12-11 940
1）功能pushd命令常用于将目录加入到栈中，加入记录到目录栈顶部，并切换到该目录；若pushd命令不加任何参数，则会将位于记录栈最上面的2个目录对换位置2）语法（1）格式：pushd  [目录 | -N | +N]   [-n]（2）选项目录   将该目录加入到栈顶，并执行"cd 目录"，切换到该目录+N   将第N个目录移至栈顶（从左边数起，数字从0开始）-N    将第N个目录移至栈顶（从右...
push推送详解链接
weixin_30439131的博客
07-07 6407
http://blog.csdn.net/shenjie12345678/article/details/41120637/ 转载于:https://www.cnblogs.com/sunjianfei/p/5651084.html
push翻译计算机,push是什么意思_push翻译_读音_用法_翻译
weixin_31046701的博客
07-27 4627
vipkid提供push是什么意思、push英语单词推荐、push英语解释、push相关词、push英语短语英音 [pʊʃ] 美音 [pʊʃ]【中文释义】vt.& vi. 推，推动;vt. 推动，增加;对…施加压力，逼迫;按;说服;n. 推，决心;大规模攻势;矢志的追求;vi. 推进;增加;努力争取;【英文释义】Noun:the act of applying ...
Learning Modern OpenGL
weixin_30361641的博客
05-25 262
From:http://www.codeproject.com/Articles/771225/Learning-Modern-OpenGL A little guide about modern OpenGL and why it gives us so much value. Shaders + Cube Env Map + Phong Lighting In...
基础总结篇之三：Activity的task相关
t225com
09-30 476
古人學問無遺力，少壯工夫老始成。紙上得來終覺淺，絕知此事要躬行。南宋.陸遊《冬夜讀書示子聿(yù)》 软件行业也是一样，多少前辈不遗余力的奋斗才出现了软件行业的繁荣的景象，其中已有不少成为大师级人物。今天我们站在伟人的肩膀上，自然会有不少的优势，但不要忘了，要在对技术的认知方面有所提升，仍需我们去实践，去实践。 今天我们来讲一下Activity的task相关内容。 上次我们讲到Activit...
vector push_back报错 是其他地方内存越界覆盖掉了后面的内存
boshuzhang的专栏
02-22 8637
最近在运行一个较大的程序，内存占用可能有点多，其中在vector.push_back()处报错，感到很奇怪。用g++ -std=c++11编译。 下面是与报错相关的部分。 vector KATT; KATT.clear(); int KATT2; ...... ...... ...... KATT.push_back(KATT2); 程序输出及报错信息： KATT2 =  
PyQt5基本控件详解之QClipboard（二十一）
jia666666的博客
08-11 3981
QClipboard 前言 QClipboard类提供了对系统剪切板的访问，可以在应用程序之间复制和粘贴数据，它的操作类似于QDrag类，，并使用类似的数据结构 QApplication类有一个静态方法clipboard（），它的返回值对剪切板对象的引用，任何类型的MimeData都可以从剪切板复制或粘贴 QClipboard类中的常用方法如表 方法 描...
push方法总结
蕉下客
07-13 1万+
jQuery中push方法表示向数组后添加元素，仅限于数组，这点和append和after是根本区别，pop表示从数组中取出最后一个元素。push返回添加之后的数组长度，而pop返回的是数组的最后一个元素。 ss var arr = []; arr.push("tom"); arr.push("jack"); document.write(arr);          
cannot use unsafe construct in safe context
最新发布
06-09
这是一个编译错误，意思是在安全上下文中不能使用不安全的构造。这通常出现在使用一些不安全的语言特性时，例如指针操作或裸指针。在安全上下文中，编译器会强制执行一些安全规则，以确保程序的安全性和稳定性。如果需要使用不安全的构造，可以将其包装在`unsafe`块中，这样编译器会知道这是有意为之，并且不会出现编译错误。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值