Visual basic Image Processing Embossing Filter source Code

IntroductionVisual Basic CodeDownload

VB.net can Emboss an image quickly with this short bit of code. Make sure the following imports are included at the top of your module. To apply the filter, the program considers each pixel in the image (except those on the very edges of the image). It looks at the 3x3 square of pixels surrounding the target pixel and multiplies their red, green, and blue component values by the corresponding filter value. It adds the results and divides by the filter's weight. For an embossing filter, the program then adds 127 to make pixels with a neutral value become gray.
Note that the embossing filter only has two non-zero values and that its weight is 1. You can improve performance slightly by performing the multiplications directly rather than by looping through the filter array. That makes the code a bit less general, however, so it would be harder to modify to apply other filters. For example, try changing the values in the filter array and then setting the weight to the sum of the values in the array to see what happens.


Start	Embossed

Public Class Emboss

' Provide public access to the picture's byte data.
Public ImageBytes() As Byte
Public RowSizeBytes As Integer
Public Const PixelSizeBytes As Integer = 3
Public Const PixelSizeBits As Integer = PixelSizeBytes * 8

' Save a reference to the bitmap.
Public Sub New(ByVal bm As Bitmap)
  m_Bitmap = bm

'Create Matrix
   m_Filter = New Integer(,) _
         {{-1, 0, 0}, _
          {0, 0, 0}, _
          {0, 0, 1}}

m_Weight = 1
End Sub<br />

' A reference to the Bitmap.
Private m_Bitmap As Bitmap

' Bitmap data.
Private m_BitmapData As BitmapData
Private m_Filter(,) As Integer
Private m_Weight As Integer

Public Function emboss(ByVal Myimage As Image) As Image
  Dim start_time As Date = Now
  Dim bm1 As Bitmap = Myimage
  Dim bm2 As New Bitmap(bm1.Width, bm1.Height)
  
' Make BitmapBytesRGB24 objects for the bitmaps.
        Dim bm1_bytes As New BitmapBytesRGB24(bm1)
        Dim bm2_bytes As New BitmapBytesRGB24(bm2)

' Lock the bitmaps' bytes.
        bm1_bytes.LockBitmap()
        bm2_bytes.LockBitmap()
        Dim Width As Integer = bm1.Width
        Dim Height As Integer = bm1.Height
        Dim new_r As Byte = 0
        Dim new_g As Byte = 0
        Dim new_b As Byte = 0
        For x As Integer = 1 To Width - 2
            For y As Integer = 1 To Height - 2
                Dim r As Integer = 0
                Dim g As Integer = 0
                Dim b As Integer = 0
                For dx As Integer = 0 To 2
                    For dy As Integer = 0 To 2
                        bm1_bytes.GetPixel(x + dx - 1, y + dy - 1, new_r, new_g, new_b)
                        r += new_r * m_Filter(dx, dy)
                        g += new_g * m_Filter(dx, dy)
                        b += new_b * m_Filter(dx, dy)
                    Next dy
                Next dx
                
                r = CInt(127 + r / m_Weight)
                g = CInt(127 + g / m_Weight)
                b = CInt(127 + b / m_Weight)
                If r < 0 Then r = 0
                If g < 0 Then g = 0
                If b < 0 Then b = 0
                If r > 255 Then r = 255
                If g > 255 Then g = 255
                If b > 255 Then b = 255
                bm2_bytes.SetPixel(x, y, r, g, b)
            Next y
        Next x

' Unlock the bitmaps.
        bm1_bytes.UnlockBitmap()
        bm2_bytes.UnlockBitmap()

Return bm2<br />
End Function

' Lock the bitmap's data.
Public Sub LockBitmap()

' Lock the bitmap data.
        Dim bounds As Rectangle = New Rectangle(0, 0, m_Bitmap.Width, m_Bitmap.Height)
        m_BitmapData = m_Bitmap.LockBits(bounds, Imaging.ImageLockMode.ReadWrite, Imaging.PixelFormat.Format24bppRgb)
        RowSizeBytes = m_BitmapData.Stride

' Allocate room for the data.
        Dim total_size As Integer = m_BitmapData.Stride * m_BitmapData.Height
        ReDim ImageBytes(total_size)

' Copy the data into the ImageBytes array.
        Marshal.Copy(m_BitmapData.Scan0, ImageBytes, 0, total_size)
End Sub

' Copy the data back into the Bitmap and release resources.
Public Sub UnlockBitmap()

' Copy the data back into the bitmap.
        Dim total_size As Integer = m_BitmapData.Stride * m_BitmapData.Height
        Marshal.Copy(ImageBytes, 0, m_BitmapData.Scan0, total_size)
        
' Unlock the bitmap.
        m_Bitmap.UnlockBits(m_BitmapData)

' Release resources.
        ImageBytes = Nothing
        m_BitmapData = Nothing
End Sub

' Return a pixel's byte values.
Public Sub GetPixel(ByVal x As Integer, ByVal y As Integer, ByRef r As Byte, ByRef g As Byte, ByRef b As Byte)
   Dim offset As Integer = y * RowSizeBytes + x * PixelSizeBytes
        b = ImageBytes(offset)
        g = ImageBytes(offset + 1)
        r = ImageBytes(offset + 2)
End Sub

' Set a pixel's byte values.
Public Sub SetPixel(ByVal x As Integer, ByVal y As Integer, ByVal r As Byte, ByVal g As Byte, ByVal b As Byte)
        Dim offset As Integer = y * RowSizeBytes + x * PixelSizeBytes
        ImageBytes(offset) = b
        ImageBytes(offset + 1) = g
        ImageBytes(offset + 2) = r
End Sub

End Class

Download

Finish

Thank you for viewing this source code. If you want to download the project files and a copy of this source code you must either fill out this form with a valid email address as some useful commets about this site or you may become a member free of charge. In either case a link will be emailed where you can down load the project filess.

Name
Email
Comment

	Excalibur Software Solutions Images
Please login	Home > Image Processing > Embossing filter

Visual basic Code Sample Image Embossing