(sorry, screwed up the previous post and its edit... here it is complete)
i am sorry to digress a bit, but...
if you need to make your processing faster DO NOT EVER USE imaqImageToArray !
as
you may know, NI Vision (and about any other image processing library)
stores image in memory in a single long row of pixel values. this is
called an image buffer. next to the image buffer is a set of attributes
which tells the real width and height of the image, as well as its
pixel format, etc... in order to be efficient when processing an image,
a row of pixel in the buffer is often longer than the real width of the
image: this is called padding, and allows to make memory transfert or
processing by blocks of multiple bytes. also, images may contain a
border around to allow for some processing (convolutions...) to execute
properly. so a buffer contains a lot more informations than just image
pixels.
then, when you use imaqImageToArray, it will
physically copy all the relevant pixel of the image into a new buffer,
removing any superfluous byte, and this copy takes a lot of time.
generally, after calling imaqImageToArray and performing some
processing, you have to call imaqArrayToImage to put the pixels back
into the image buffer, which takes a lot of time again. this is clearly
not efficient and should be avoided if performance is your concern. for
real fast home-made processing, write directly into image buffer...
to
process your buffer directly (which is completely normal: everybody
does just that... well, not quite everybody...), use the
imaqGetImageInfo function. it returns a structure describing the layout
of the pixels in memory:
- imageStart is the address in memory of the first pixel of your image (coord 0,0)
- xRes is the width of your image (same as what is returned by imaqGetImageSize)
- pixelsPerLine is the real number of pixels for each line into the buffer.
(it is still missing a field describing the number of bytes per pixels)
let's try:
Image *img; // let's say this variable contains a valid image grayscale image
ImageInfo info;
imaqGetImageInfo( img, &info );
now you can access any pixel into the buffer:
unsigned char *pixel_address = (unsigned char *)info.imageStart + y * info.pixelsPerLine + x;
unsigned char pixel_value = *pixel_address; // or combine this with the previous line to get direclty the pixel value
you can also go through your entire image:
for ( int y = 0; y < info.yRes; y++ )
{
for ( int x = 0; x < info.xRes; x++ )
{
pixel_address = (unsigned char *)info.imageStart + y * info.pixelsPerLine + x;
// proces your pixel straight into the buffer here...
}
}
more efficient:
unsigned char *pixel = info.imageStart;
for ( int y = 0; y < info.yRes; y++ )
{
for ( int x = 0; x < info.xRes; x++ )
{
// proces your pixel straight into the buffer here...
pixel += 1;
}
pixel += info.pixelsPerLine - info.xRes; // jump over all padding and border
}
it can be made as efficient as you want (beware: CVI is NOT an optimizing compiler, optimize it yourself)
of
course, if your image is not grayscale 8bit per pixel, you have to
adjust the data type used for the pointer arithmetic, or add a factor
to the pixel address computation.
THIS will make your computing
faster. and you will not have to understand the call to
imaqImageToArray which is badly documented and has no working example.
(next post, i show you how to write your own image processing library... :p)
