Fast image processing in C#
Michael A. Covington
in C#?
Using GetPixel to access every pixel from a Bitmap seems to be rather
time-consuming.
sherifffruitfly
All of the little I've seen uses Unsafe code.
Michael A. Covington
The Code Project.
I'm going to look at them. Unsafe code might be the right thing to use.
Michael C
news:u947C5qZ...@TK2MSFTNGP03.phx.gbl...
> Thanks. After posting my message I realized there were several examples
> on The Code Project.
>
> I'm going to look at them. Unsafe code might be the right thing to use.
Depends on what you're doing. Converting to grayscale for example can be
done all in managed with similar speed.
>
>
sherifffruitfly
> "Michael A. Covington" <l...@ai.uga.edu.for.address> wrote in messagenews:u947C5qZ...@TK2MSFTNGP03.phx.gbl...
>
> > Thanks. After posting my message I realized there were several examples
> > on The Code Project.
>
> > I'm going to look at them. Unsafe code might be the right thing to use.
>
> Depends on what you're doing. Converting to grayscale for example can be
> done all in managed with similar speed.
unsafe != unmanaged, right?
http://www.programmersheaven.com/2/FAQ-DOTNET-Unmanaged-Unsafe-Code-Differences
Michael C
> Here's what I wound up creating:
>
> www.ai.uga.edu/mc/CovingtonImageProcessing.zip
>
> It's only moderately fast, but fast enough for my purposes. I ended up
> using LockBits and Marshal.Copy to copy the image data into an array, then
> doing the opposite after processing.
There is no reason to do this in c#, it slows the whole process down.
> That way I don't have to do a method call on every single pixel,
> especially when doing things like convolutions.
I don't see how it makes any difference. If you're doing image processing
you'll have to look at every pixel whether it's in an array or not.
Michael
Michael A. Covington
"Michael C" <nos...@nospam.com> wrote in message
news:O%23r9v0aa...@TK2MSFTNGP04.phx.gbl...
> "Michael A. Covington" <lo...@ai.uga.edu.for.address> wrote in message
> news:uuow18Za...@TK2MSFTNGP05.phx.gbl...
>> Here's what I wound up creating:
>>
>> www.ai.uga.edu/mc/CovingtonImageProcessing.zip
>>
>> It's only moderately fast, but fast enough for my purposes. I ended up
>> using LockBits and Marshal.Copy to copy the image data into an array,
>> then doing the opposite after processing.
>
> There is no reason to do this in c#, it slows the whole process down.
Are you saying I shouldn't use C# or shouldn't use LockBits and
Marshal.Copy? I know it's possible to use pointers also.
>> That way I don't have to do a method call on every single pixel,
>> especially when doing things like convolutions.
>
> I don't see how it makes any difference. If you're doing image processing
> you'll have to look at every pixel whether it's in an array or not.
It makes a tremendous difference not to have to call GetPixel every time I
want to see the value of a pixel, particularly when doing matrix
convolutions.
Anyhow, the program is now fast enough for my purposes.
Michael C
> Are you saying I shouldn't use C# or shouldn't use LockBits and
> Marshal.Copy? I know it's possible to use pointers also.
You should use C# and LockBits but not Marshal.Copy. As you've suggested you
should use pointers instead. If you're unfamiliar it's fairly simple:
byte* ptr= (byte*)Data.Scan0;
int offset = data.stride - data.width * 3;//for 24bit bitmap
for(y = 0; y < height; y++, ptr += offset)
{
for(x = 0; x > width; x++, ptr += 3)
{
byte r = data*;
//change r, then
data* = r
}
}
Michael
Michael A. Covington
appreciably different amounts of time. In your experience, how much
difference does it make?
Michael C
> Noted. I was aware of both techniques but didn't know they'd take
> appreciably different amounts of time. In your experience, how much
> difference does it make?
I'm not sure as I haven't timed it. I'd imagine it would be fairly
significant as you are copying the entire bitmap twice and then doing array
lookups instead of direct pointer access. There'd be a fair amount of checks
added to the array lookup and pretty much none for the pointer. But if you
need to avoid unsafe code then the arrays could be useful (assuming they do
in fact avoid unsafe code).
Michael
Michael A. Covington
Ah. My goal is in fact to deliver the image to the user in an ordinary int
array. The program is a research test bed for developing graphics
algorithms, so I need to express the algorithms as simply as possible and
run them with checking in place.
I thought you were suggesting copying the image to the array using pointers
instead of using Marshal.Copy (which is already very fast).
Michael C
> Ah. My goal is in fact to deliver the image to the user in an ordinary
> int array. The program is a research test bed for developing graphics
> algorithms, so I need to express the algorithms as simply as possible and
> run them with checking in place.
Why are you doing it that way?
> I thought you were suggesting copying the image to the array using
> pointers instead of using Marshal.Copy (which is already very fast).
No, you won't get any faster if you do the copy. I was suggesting
eliminating the copy. :-)
>
>
Michael A. Covington
> "Michael A. Covington" <lo...@ai.uga.edu.for.address> wrote in message
> news:e4UYlqo...@TK2MSFTNGP05.phx.gbl...
>> Ah. My goal is in fact to deliver the image to the user in an ordinary
>> int array. The program is a research test bed for developing graphics
>> algorithms, so I need to express the algorithms as simply as possible and
>> run them with checking in place.
>
> Why are you doing it that way?
As I said, to test algorithms. I am interested in the computation, not (at
this stage) the fastest implementation of it. It may end up implemented
some totally different way.
Rao Muhammad Rafique
you can use BitmapData class along with LocBits() and UnLock() methods.also
with unsafe context and pointers.that make the image processing fast.
further detail contact:
rao2...@yahoo.com