| Image
Processing Articles
Index |
 |
| The
C# provides a good
support for processing
on the image, and
the purpose of this
article is not to
give you a lot of
insight into the image
processing, rather
it is written to help
you start your image
processing career
using C#. The article
contains: |
|
 Displaying
Image in the Dialog
Box
Basic
Image Library Documentation
Locking
and Unlocking the
image
Basic
Layout of the Locked
Array
Iterating
in the Image |
|
| Displaying
Image in the Dialog
Box |
| The
image can be displayed
in the dialog box
using C# by using
the PictureBox tool
from the Toolbox.
To see this lets create
a project and display
an image in it using
PictureBox. To do
this, follow these
steps: |
|
|
1). Click File>New>Project,
the following dialog
box will appear: |
|
 |
|
2).
Enter the desired
project name, location
and then click OK.
Now a project is created.
3). This will show
the default form of
the project.
4). Select the PictureBox
from the Toolbox and
draw it on the form
of the desired size
and adjus its properties
as wanted.
5). This will add
an instantiation of
the PictureBox class's
instantiation in the
Form1 class.
6). Create an object
of the class Bitmap
by giving the address
of the desired file
in the constructure
as:
Bitmap bmp = new Bitmap(
"c:/images/image.gif"
);
7). Now assign the
Image member of the
class the bmp objec
as:
picturebox1.Image
= bmp;
8). Call the Invalidate(
) function of the
form class.
9). Now the image
will be shown in the
PictureBox in during
execution in the similar
way as shown in the
diagram below: |
|
 |
|
| Basic
Image Library Documentation |
| The
microsoft .net framework
provides a rich library
for working in any
field. It also gives
the support for processing
on the images. The
basic library support
is documented below: |
|
| PictureBox
class |
| ClientRectangle:
ClientRectangle is
a public property
representing a rectangle
that represents the
client area of the
control. It does not
include the elements
such as scroll bars,
borders, title bars,
and menus. It only
represent the area
in which the image
is drawn actually. |
|
| Image:
The public property
representation of
the Image class to
display. The Image
property is set to
the image to display.
You can do this either
at design time or
at run time. |
|
| SizeMode:
The property showing
how to display the
image. |
|
| Refresh:
Function that forces
the control to invalidate
its client area and
immediately redraw
itself and any child
controls. |
|
| Update:
Function that causes
the control to redraw
the invalidated regions
within its client
area. |
|
| Bitmap
Class |
| The
Bitmap class is the
generalization of
the Image class. Note
above that, the PictureBox
class contains a refrence
of the image class,
but the Image class
is an abstract class,
so its objects can
be instantiated and
PictureBox objects
contains the instantiations
of the Image class's
derived classes, one
of which is the Bitmap
class.. |
|
| Constructor:
Bitmap class contains
12 constructors that
construct the Bitmap
object from different
parameters. It can
construct the Bitmap
from another bitmap,
and the string address
of the image. It also
provides the constructors
the Bitmap object
from Bitmap( int width
, int height ). |
|
| PixelFormat:
PixelFormat is the
public property of
the image of this
image object. |
|
| Clone:
This is the overloaded
function of the Bitmap
class inherited from
the Object class that
returns the copy of
the object on which
the function was orignaly
invoked. |
|
| GetPixel:
The public function
that get the color
of the specified pixel. |
|
| LockBits
and UnLockBits: The
public functions in
the class that locks
and unlocks the specified
area of the image
into the memory. The
paramenters of the
LockBits function
are, a Rectangle object
specifying the area
to be Locked, then
2 integers specifying
the access level for
the object and the
other showing the
format of the image.
This is done through
two enumirations like
ImageLockMode, and
PixelFormat. They
are narrated after
this class. The LockBits
returns the object
of the BitmapData
class and UnLockBits
takes the object of
the BitmapData class. |
|
| BitmapData
LockBits( Rectangle
, ImageLockMode ,
PixelFormat ); |
|
| SetPixel:
The public function
that sets the color
of the specified pixel.
|
|
| ImageLockMode
Enumiration |
| Specifies
flags that are passed
to the flags parameter
of the LockBits method.
It has four members. |
|
| ReadOnly:
Specifies that a portion
of the image is locked
for reading. |
|
| ReadWrite:
Specifies that a portion
of the image is locked
for reading or writing. |
|
| UserInputBuffer:
Specifies that the
buffer used for reading
or writing pixel data
is allocated by the
user. |
|
| WriteOnly:
Specifies that a portion
of the image is locked
for writing. |
|
| BitmapData
class |
|
Scan0: The address
of the first byte
in the locked array.
If whole of the image
is locked, then it
is the first byte
of the image. |
|
| Stride:
The width, in bytes,
of a single row of
pixel data in the
locked array. This
width is a multiple,
or possibly sub-multiple,
of the pixel dimensions
of the image and may
be padded out to include
a few more bytes.
I'll explain why shortly. |
|
| Width:
The width of the locked
image. |
|
| Height:
The height of the
locked image. |
|
| PixelFormat:
The actual pixel format
of the data. |
|
| PixelFormat
Class |
| The
pixel format defines
the number of bits
of memory associated
with one pixel of
data. In other words
the format defines
the order of the color
components within
a single pixel of
data. Normaly, PixelFormat.Format24bppRgb
is used. PixelFormat.Format24bppRgb
specifies that the
format is 24 bits
per pixel; 8 bits
each are used for
the red, green, and
blue components. In
the 24 bit format
image, the image consists
of pixels consisting
of 3 bytes, one for
each red, green, and
blue. The first byte
in the image contains
the blue color, the
second byte contains
the green color, and
the third byte contains
the red color of the
pixel, and they form
the color of the specified
pixel. |
|
| Basic
Layout of the Locked
Array |
| Scan0
is the pointer to
the 1st byte in the
pixel array of the
image which contains
Height no. of rows
and each row contains
Stride no. of bytes
in every row as shown
in the diagram: |
|
 |
|
| Each
row contains the data
of Width no. of pixels,
where each pixel consists
of PixelFormat no.
of bytes. Thus total
space taken by the
Width no. of pixels
is |
|
| Total
space taken by Width
no. Pixels = Width(
no. of Pixels ) X
PixelFormat( no. of
bytes per pixel ) |
|
| This
space is aproximately
equal to the Stride,
but not exactly equal
to it. In fact due
to efficiency reasons,
it is ensured that
the Stride of an image
contains a no. multiple
of 4. For example,
if an image is in
24 bits per pixel,
and contains 25 pixel
in each row, then
it needs total space
in each row equal
to ( 75 = 3 X 25 ),
but 75 is not the
multiple of 4. Hence,
the next multiple
of 4 is used and in
this case it is 76.
Hence, 1 byte is remained
unused as shown by
the black area in
every row in the above
diagram. If space
needed by the Width
no. bytes is a multiple
of 4, then the Stride
is equal to it, and
hence, there is no
unused space mentioned
as black area in the
above diagram. |
|
| Iterating
through the Image |
First
of all create the
Bitmap object as:
Bitmap image = new
Bitmap( "c:\\images\\image.gif"
);
Then get the BitmapData
object from it by
calling the Lock method
as: |
|
| Then
get the BitmapData
object from it by
calling the Lock method
as: |
|
| BitmapData
data = image.LockBits(
new Rectangle( 0 ,
0 , image.Width ,
image.Height ) , ImageLockMode.ReadWrite
, PixelFormat.Format24bppRgb
); |
|
| Then
you can iterate in
the image as: |
|
unsafe
{
byte* imgPtr = ( byte*
)( data.Scan0 );
for( int i = 0 ; i
< data.Height ;
i ++ )
{
for( int j = 0 ; j
< data.Width ;
j ++ )
{
// write the logic
implementation here
ptr += 3;
}
ptr += data.Stride
- data.Width * 3;
}
} |
|
| Here
unsafe, shows that
you need to use the
pointers in the unmanaged
block, and the statement: |
|
| ptr
+= data.Stride - data.Width
* 3; |
|
| shows
that you need to skip
the unused space. |
|
| Basic
Difference Between
Unsafe and GDI+ |
| GDI
is comparatively less
efficient due to the
overheads involved
for Graphics adapters
and windows messaging
but working on image
processing in unsafe
mode provides extensively
great performance
parameters. |
|
| Image
Processing Articles
Index |
