C# GDI | Software by Default

Posts Tagged 'C# GDI'

C# How to: Image Arithmetic

Article Purpose

The objective of this article is to illustrate Image Arithmetic being implemented when blending/combining two separate images into a single result image. The types of Image Arithmetic discussed are: Average, Add, SubtractLeft, SubtractRight, Difference, Multiply, Min, Max and Amplitude.

I created the following image by implementing Image Arithmetic using as input images a photo of a friend’s ear and a photograph taken at a live concert performance by The Red Hot Chili Peppers.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the Sample Application

The Sample source code accompanying this article includes a Sample Application developed on a Windows Forms platform. The Sample Application is indented to provide an implementation of the various types of Image Arithmetic explored in this article.

The Image Arithmetic sample application allows the user to select two source/input images from the local file system. The user interface defines a ComboBox dropdown populated with entries relating to types of Image Arithmetic.

The following image is a screenshot taken whilst creating the “Red Hot Chili Peppers Concert – Side profile Ear” blended image illustrated in the first image shown in this article. Notice the stark contrast when comparing the source/input preview images. Implementing Image Arithmetic allows us to create a smoothly blended result image:

Newly created images can be saved to the local file system by clicking the ‘Save Image’ button.

Image Arithmetic

In simple terms Image Arithmetic involves the process of performing calculations on two images’ corresponding pixel colour components. The values resulting from performing calculations represent a single image which is combination of the two original source/input images. The extent to which a source/input image will be represented in the resulting image is dependent on the type of Image Arithmetic employed.

The ArithmeticBlend Extension method

In this article Image Arithmetic has been implemented as a single extension method targeting the Bitmap class. The ArithmeticBlend extension method expects as parameters two source/input Bitmap objects and a enumeration value indicating the type of Image Arithmetic to perform.

The ColorCalculationType enum defines an enumeration value for each type of Image Arithmetic supported. The definition as follows:

public enum ColorCalculationType 
{ 
   Average, 
   Add, 
   SubtractLeft, 
   SubtractRight, 
   Difference, 
   Multiply, 
   Min, 
   Max, 
   Amplitude 
}

It is only within the ArithmeticBlend extension method that we perform Image Arithmetic. This method accesses the underlying pixel data of each sample image and creates copies stored in byte arrays. Each element within the byte array data buffer represents a single colour component, either Alpha, Red, Green or Blue.

The following code snippet details the implementation of the ArithmeticBlend extension method:

 public static Bitmap ArithmeticBlend(this Bitmap sourceBitmap, Bitmap blendBitmap,  
                                 ColorCalculator.ColorCalculationType calculationType) 
{ 
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle (0, 0, 
                            sourceBitmap.Width, sourceBitmap.Height), 
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 
    sourceBitmap.UnlockBits(sourceData); 

   
    BitmapData blendData = blendBitmap.LockBits(new Rectangle (0, 0, 
                           blendBitmap.Width, blendBitmap.Height), 
                           ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] blendBuffer = new byte [blendData.Stride * blendData.Height]; 
    Marshal.Copy(blendData.Scan0, blendBuffer, 0, blendBuffer.Length); 
    blendBitmap.UnlockBits(blendData); 

   
    for (int k = 0; (k + 4 < pixelBuffer.Length) && 
                    (k + 4 < blendBuffer.Length); k += 4) 
    { 
        pixelBuffer[k] = ColorCalculator.Calculate(pixelBuffer[k],  
                            blendBuffer[k], calculationType); 

   
        pixelBuffer[k + 1] = ColorCalculator.Calculate(pixelBuffer[k + 1],  
                                blendBuffer[k + 1], calculationType); 

   
        pixelBuffer[k + 2] = ColorCalculator.Calculate(pixelBuffer[k + 2],  
                                blendBuffer[k + 2], calculationType); 
    } 

   
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

   
    BitmapData resultData = resultBitmap.LockBits(new Rectangle (0, 0, 
                            resultBitmap.Width, resultBitmap.Height), 
                            ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

   
    Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

   
    return resultBitmap; 
}

We access and copy the underlying pixel data of each input bitmap by making use of the Bitmap.LockBits method and also the Marshal.Copy method.

The method iterates both byte array data buffers simultaneously, having set the for loop condition to regard the array size of both byte arrays. Scenarios where byte array data buffers will differ in size occurs when the source images specified are not equal in terms of size dimensions.

Notice how each iteration increments the loop counter by a factor of four allowing us to treat each iteration as a complete pixel value. Remember that each data buffer element represents an individual colour component. Every four elements represents a single pixel consisting of the components: Alpha, Red, Green and Blue.

Take Note: The ordering of colour components are the exact opposite of the expected order. Each pixel’s colour components are ordered: Blue, Green, Red, Alpha. Since we are iterating an entire pixel with each iteration the for loop counter value will always equate to an element index representing the Blue colour component. In order to access the Red and Green colour components we simply add the values one and two respectively to the for loop counter value, depending on whether accessing the Green or Red colour components.

The task of performing the actual arithmetic has been encapsulated within the static Calculate method, a public member of the static class ColorCalculator. The Calculate method is more detail in the following section of this article.

The final task performed by the ArithmeticBlend method involves creating a new instance of the Bitmap class which is then updated/populated using the resulting byte array data buffer previously modified.

The ColorCalculator.Calculate method

The algorithms implemented in Image Arithmetic are encapsulated within the ColorCalculator.Calculate method. When implementing this method no knowledge of the technical implementation details are required. The parameters required are two byte values each representing a single colour component, one from each source image. The only other required parameter is an enum value of type ColorCalculationType which will indicate which type of Image Arithmetic should be implemented using the byte parameters as operands.

The following code snippet details the full implementation of the ColorCalculator.Calculate method:

 public static byte Calculate(byte color1, byte color2, 
                   ColorCalculationType calculationType) 
{ 
    byte resultValue = 0; 
    int intResult = 0; 

  
    if (calculationType == ColorCalculationType.Add) 
    { 
        intResult = color1 + color2; 
    } 
    else if (calculationType == ColorCalculationType.Average) 
    { 
        intResult = (color1 + color2) / 2; 
    }
    else if (calculationType == ColorCalculationType.SubtractLeft) 
    {
        intResult = color1 - color2; 
    } 
    else if (calculationType == ColorCalculationType.SubtractRight) 
    { 
        intResult = color2 - color1; 
    }
    else if (calculationType == ColorCalculationType.Difference) 
    { 
        intResult = Math.Abs(color1 - color2); 
    }
    else if (calculationType == ColorCalculationType.Multiply) 
    {
        intResult = (int)((color1 / 255.0 * color2 / 255.0) * 255.0); 
    }
    else if (calculationType == ColorCalculationType.Min) 
    {
        intResult = (color1 < color2 ? color1 : color2); 
    } 
    else if (calculationType == ColorCalculationType.Max) 
    {
        intResult = (color1 > color2 ? color1 : color2); 
    }
    else if (calculationType == ColorCalculationType.Amplitude) 
    {
        intResult = (int)(Math.Sqrt(color1 * color1 + color2 * color2) 
                                                    / Math .Sqrt(2.0)); 
    } 

  
    if (intResult < 0) 
    {
        resultValue = 0; 
    } 
    else if (intResult > 255) 
    {
         resultValue = 255; 
    } 
    else 
    { 
        resultValue = (byte)intResult; 
    }

  
    return resultValue; 
}

The bulk of the ColorCalculator.Calculate method’s implementation is set around a series of if/else if statements evaluating the enum method parameter passed when the method had been invoked.

Colour component values can only range from 0 to 255 inclusive. Calculations performed might result in values which do not fall within the valid range of values. Calculated values less than zero are set to zero and values exceeding 255 are set to 255, sometimes this is referred to clamping.

The following sections of this article provides an explanation of each type of Image Arithmetic implemented.

Image Arithmetic: Add

if (calculationType == ColorCalculationType.Add)
{
    intResult = color1 + color2;
}

The Add algorithm is straightforward, simply adding together the two colour component values. In other words the resulting colour component will be set to equal the sum of both source colour component, provided the total does not exceed 255.

Sample Image

Image Arithmetic: Average

if (calculationType == ColorCalculationType.Average)
{
    intResult = (color1 + color2) / 2;
}

The Average algorithm calculates a simple average by adding together the two colour components and then dividing the result by two.

Sample Image

Image Arithmetic: SubtractLeft

if (calculationType == ColorCalculationType.SubtractLeft)
{
    intResult = color1 - color2;
}

The SubtractLeft algorithm subtracts the value of the second colour component parameter from the first colour component parameter.

Sample Image

Image Arithmetic: SubtractRight

if (calculationType == ColorCalculationType.SubtractRight)
{
    intResult = color2 - color1;
}

The SubtractRight algorithm, in contrast to SubtractLeft, subtracts the value of the first colour component parameter from the second colour component parameter.

Sample Image

Image Arithmetic: Difference

if (calculationType == ColorCalculationType.Difference)
{
    intResult = Math.Abs(color1 - color2);
}

The Difference algorithm subtracts the value of the second colour component parameter from the first colour component parameter. By passing the result of the subtraction as a parameter to the Math.Abs method the algorithm ensures only calculating absolute/positive values. In other words calculating the difference in value between colour component parameters.

Sample Image

Image Arithmetic: Multiply

if (calculationType == ColorCalculationType.Multiply)
{
    intResult = (int)((color1 / 255.0 * color2 / 255.0) * 255.0);
}

The Multiply algorithm divides each colour component parameter by a value of 255 and the proceeds to multiply the results of the division, the result is then further multiplied by a value of 255.

Sample Image

Image Arithmetic: Min

if (calculationType == ColorCalculationType.Min)
{
    intResult = (color1 < color2 ? color1 : color2);
}

The Min algorithm simply compares the two colour component parameters and returns the smallest value of the two.

Sample Image

Image Arithmetic: Max

if (calculationType == ColorCalculationType.Max)
{
    intResult = (color1 > color2 ? color1 : color2);
}

The Max algorithm, as can be expected, will produce the exact opposite result when compared to the Min algorithm. This algorithm compares the two colour component parameters and returns the larger value of the two.

Sample Image

Image Arithmetic: Amplitude

 else if (calculationType == ColorCalculationType.Amplitude) 
{ 
         intResult = (int)(Math.Sqrt(color1 * color1 +
                                     color2 * color2) /
                                     Math.Sqrt(2.0)); 
}

The Amplitude algorithm calculates the amplitude of the two colour component parameters by multiplying each colour component by itself and then sums the results. The last step divides the result thus far by the square root of two.

Sample Image

C# How to: Bitwise Bitmap Blending

Published April 22, 2013 Augmented Reality , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Microsoft , Opensource , Wikipedia 41 Comments
Tags: Alpha Red Green Blue, ARGB, Augmented Reality, Bitmap, Bitmap Blending, Bitmap Filters, Bitmap.LockBits, BitmapData, Bitwise Bitmap, Bitwise Bitmap Blending, C#, C# GDI, Graphic Filters, Image Contrast, Image Filters, Image Manipulation, Image Transform, Open source, Opensource, Pixel Filters, Pixel Manipulation

Article Purpose

In this article you’ll find a discussion on the topic of blending Bitmap images into a single Image. Various possible methods can be employed in blending images. In this scenario image blending is achieved through means of bitwise operations, implemented on individual colour components Red, Green and Blue.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Bitwise Operations

In this article we will be implementing the following bitwise operators:

& Binary And
| Binary Or
^ Exclusive Binary Or (XOR)

A good description of how these operators work can be found on MSDN:

The bitwise-AND operator compares each bit of its first operand to the corresponding bit of its second operand. If both bits are 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

The bitwise-exclusive-OR operator compares each bit of its first operand to the corresponding bit of its second operand. If one bit is 0 and the other bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

The bitwise-inclusive-OR operator compares each bit of its first operand to the corresponding bit of its second operand. If either bit is 1, the corresponding result bit is set to 1. Otherwise, the corresponding result bit is set to 0.

Using the sample Application

Included with this article is a Visual Studio solution containing sample source code and a Windows Forms sample application. The Bitwise Bitmap Blending Sample application allows the user to select two input/source images from the local file system. Selected source images, once specified are displayed as previews with the majority of the application front end being occupied by an output PictureBox.

The following image is a screenshot of the Bitwise Bitmap Blending application in action:

If the user decides to, blended images can be saved to the local file system by clicking the Save button.

The BitwiseBlend Extension method

The Sample Source provides the definition for the BitwiseBlend extension method. This method’s declaration indicates being an extension method targeting the Bitmap class.

The BitwiseBlend method requires 4 parameters: the Bitmap being blended with and three parameters all of enum type BitwiseBlendType. The enumeration defines the available blending types in regards to bitwise operations. The following code snippet provides the definition of the BitwiseBlendType enum:

public enum BitwiseBlendType  
{
   None,
   Or,
   And,
   Xor
}

The three BitwiseBlendType parameters relate to a pixel’s colour components: Red, Green and Blue.

The code snippet below details the implementation of the BitwiseBlend Extension method:

 public static Bitmap BitwiseBlend(this Bitmap sourceBitmap, Bitmap blendBitmap,  
                                     BitwiseBlendType blendTypeBlue, BitwiseBlendType  
                                     blendTypeGreen, BitwiseBlendType blendTypeRed) 
 { 
     BitmapData sourceData = sourceBitmap.LockBits(new Rectangle(0, 0, 
                             sourceBitmap.Width, sourceBitmap.Height), 
                             ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

 
     byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 
     Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 
     sourceBitmap.UnlockBits(sourceData); 

 
     BitmapData blendData = blendBitmap.LockBits(new Rectangle(0, 0, 
                             blendBitmap.Width, blendBitmap.Height), 
                             ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

 
     byte[] blendBuffer = new byte[blendData.Stride * blendData.Height]; 
     Marshal.Copy(blendData.Scan0, blendBuffer, 0, blendBuffer.Length); 
     blendBitmap.UnlockBits(blendData); 

 
     int blue = 0, green = 0, red = 0; 

 
     for (int k = 0; (k + 4 < pixelBuffer.Length) &&  
                     (k + 4 < blendBuffer.Length); k += 4) 
     { 
         if (blendTypeBlue == BitwiseBlendType.And) 
         { 
             blue = pixelBuffer[k] & blendBuffer[k]; 
         } 
         else if (blendTypeBlue == BitwiseBlendType.Or) 
         { 
             blue = pixelBuffer[k] | blendBuffer[k]; 
         } 
         else if (blendTypeBlue == BitwiseBlendType.Xor) 
         { 
             blue = pixelBuffer[k] ^ blendBuffer[k]; 
         } 

 
         if (blendTypeGreen == BitwiseBlendType.And) 
         { 
             green = pixelBuffer[k+1] & blendBuffer[k+1]; 
         }
         else if (blendTypeGreen == BitwiseBlendType.Or) 
         { 
             green = pixelBuffer[k+1] | blendBuffer[k+1]; 
         }
         else if (blendTypeGreen == BitwiseBlendType.Xor) 
         { 
             green = pixelBuffer[k+1] ^ blendBuffer[k+1]; 
         } 

 
         if (blendTypeRed == BitwiseBlendType.And) 
         { 
             red = pixelBuffer[k+2] & blendBuffer[k+2]; 
         } 
         else if (blendTypeRed == BitwiseBlendType.Or) 
         { 
             red = pixelBuffer[k+2] | blendBuffer[k+2]; 
         }
         else if (blendTypeRed == BitwiseBlendType.Xor) 
         { 
             red = pixelBuffer[k+2] ^ blendBuffer[k+2]; 
         } 

 
         if (blue < 0) 
         { blue = 0; } 
         else if (blue > 255) 
         { blue = 255; } 

 
         if (green < 0) 
         { green = 0; } 
         else if (green > 255) 
         { green = 255; } 

 
         if (red < 0) 
         { red = 0; } 
         else if (red > 255) 
         { red = 255; } 

 
         pixelBuffer[k] = (byte)blue; 
         pixelBuffer[k + 1] = (byte)green; 
         pixelBuffer[k + 2] = (byte)red; 
     }


      Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

 
      BitmapData resultData = resultBitmap.LockBits(new Rectangle  (0, 0, 
                              resultBitmap.Width, resultBitmap.Height), 
                              ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

 
      Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
      resultBitmap.UnlockBits(resultData); 

 
      return resultBitmap; 
}

All image manipulation tasks performed by the BitwiseBlend Extension method are implemented by directly accessing a Bitmap’s underlying raw pixel data.

A Bitmap first needs to be locked in memory by invoking the Bitmap.LockBits method. Once the Bitmap object has been locked in memory the method instantiates a byte array, representing a pixel data buffer. Each element present in the data buffer reflects an individual colour component: Alpha, Red, Green or Blue.

Take note: Colour component ordering is opposite to the expected ordering. Colour components are ordered: Blue, Green, Red, Alpha. The short explanation for reverse ordering can be attributed to Little Endian CPU architecture and Blue being represented by the least significant bits of a pixel.

In order to perform bitwise operations on each pixel representing the specified Bitmaps the sample source code employs a for loop, iterating both Bitmap data buffers. The possibility exists that the two Bitmaps specified might not have the same size dimensions. Notice how the for loop defines two conditional statements, preventing the loop from iterating past the maximum bounds of the smallest Bitmap.

Did you notice how the for loop increments the defined counter by four at each loop operation? The reasoning being that every four elements of the data buffer represents a pixel, being composed of: Blue, Green, Red and Alpha. Iterating four elements per iteration thus allows us to manipulate all the colour components of a pixel.

The operations performed within the for loop are fairly straight forward. The source code checks to determine which type of bitwise operation to implement per colour component. Colour components can only range from 0 to 255 inclusive, we therefore perform range checking before assigning calculated values back to the data buffer.

The final step performed involves creating a new resulting Bitmap object and populating the new Bitmap with the updated pixel data buffer.

Sample Images

In generating the sample images two source images were specified, a sunflower and bouquet of roses. The sunflower image has been released into the public domain and can be downloaded from Wikipedia. The bouquet of roses image has been licensed under the Creative Commons Attribution-Share Alike 3.0 Unported, 2.5 Generic, 2.0 Generic and 1.0 Generic license and can be downloaded from Wikipedia.

The Original Images

The Blended Images

C# How to: Image Contrast

Published April 20, 2013 Augmented Reality , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Opensource , Wikipedia 44 Comments
Tags: Alpha Red Green Blue, ARGB, Augmented Reality, Bitmap, Bitmap Filters, Bitmap.LockBits, BitmapData, C#, C# GDI, Graphic Filters, Image Contrast, Image Filters, Image Manipulation, Image Transform, Open source, Opensource, Pixel Filters, Pixel Manipulation

Article Purpose

Adjusting the contrast of an Image is a fairly common task in image processing. This article explores the steps involved in adjusting image contrast by directly manipulating image pixels.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

What is Image Contrast?

Contrast within an image results in differences in colour and brightness being perceived. The greater the difference between colours and brightness in an image results in a greater chance of being perceived as different.

From Wikipedia we learn the following quote:

Contrast is the difference in luminance and/or color that makes an object (or its representation in an image or display) distinguishable. In visual perception of the real world, contrast is determined by the difference in the color and brightness of the object and other objects within the same field of view. Because the human visual system is more sensitive to contrast than absolute luminance, we can perceive the world similarly regardless of the huge changes in illumination over the day or from place to place.

Using the sample Application

The sample source code that accompanies this article includes a sample application, which can be used to implement, test and illustrate the concept of Image Contrast.

The Image Contrast sample application enables the user to load a source image from the local file system. Once a source image has been loaded the contrast can adjusted by dragging the contrast threshold trackbar control. Threshold values range from 100 to –100 inclusive, where positive values increase image contrast and negative values decrease image contrast. A threshold value of 0 results in no change.

The following image is a screenshot of the Image Contrast sample application in action:

The Contrast Extension Method

The sample source code provides the definition for the Contrast extension method. The method has been defined as an extension method targeting the Bitmap class.

The following code snippet details the implementation of the Contrast extension method:

 public static Bitmap Contrast(this Bitmap sourceBitmap, int threshold) 
{
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle(0, 0, 
                                sourceBitmap.Width, sourceBitmap.Height), 
                                ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] pixelBuffer = new byte  [sourceData.Stride * sourceData.Height]; 

   
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 

   
    sourceBitmap.UnlockBits(sourceData); 

   
    double contrastLevel = Math.Pow((100.0 + threshold) / 100.0, 2); 

   
    double blue = 0; 
    double green = 0; 
    double red = 0; 

   
    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    {
        blue = ((((pixelBuffer[k] / 255.0) - 0.5) *  
                    contrastLevel) + 0.5) * 255.0; 

   
        green = ((((pixelBuffer[k + 1] / 255.0) - 0.5) *  
                    contrastLevel) + 0.5) * 255.0; 

   
        red = ((((pixelBuffer[k + 2] / 255.0) - 0.5) *  
                    contrastLevel) + 0.5) * 255.0; 

   
        if  (blue > 255) 
        { blue = 255; } 
        else if  (blue < 0) 
        { blue = 0; } 

   
        if (green > 255) 
        { green = 255; } 
        else if (green < 0) 
        { green = 0; } 

   
        if (red > 255) 
        { red = 255; } 
        else if (red < 0) 
        { red = 0; } 

   
        pixelBuffer[k] = (byte)blue; 
        pixelBuffer[k + 1] = (byte)green; 
        pixelBuffer[k + 2] = (byte)red; 
    } 

   
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

   
    BitmapData resultData = resultBitmap.LockBits(new Rectangle(0, 0, 
                                resultBitmap.Width, resultBitmap.Height), 
                                ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

   
    Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

   
    return resultBitmap; 
}

In order to manipulate pixel colour component values directly we first need to lock the source Bitmap into memory by invoking the Bitmap.LockBits method. Once the source Bitmap is locked into memory we can copy the underlying pixel buffer using the Marshal.Copy method.

Based on the value of the threshold method parameter we calculate a contrast level. The formula implemented can be expressed as:

C = ((100.0 + T) / 100.0)²

Where C represents the calculated Contrast and T represents the variable threshold.

The next step involves iterating through the byte buffer of colour components. Notice how each iteration modifies an entire pixel by iterating by 4. The formula used in adjusting the contrast of a pixel’s colour components can be expressed as:

B = ( ( ( (B¹ / 255.0) – 0.5) * C) + 0.5) * 255.0

G = ( ( ( (G¹ / 255.0) – 0.5) * C) + 0.5) * 255.0

R = ( ( ( (R¹ / 255.0) – 0.5) * C) + 0.5) * 255.0

In the formula the symbols B, G and R represent the contrast adjusted colour components Blue, Green and Red. B¹, G¹ and R¹ represents the original values of the colour components Blue, Green and Red prior to being updated. The symbol C represents the contrast level calculated earlier.

Blue, Green and Red colour component values may only from 0 to 255 inclusive. We therefore need to test if the newly calculated values fall within the valid range of values.

The final operation performed by the Contrast method involves copying the modified pixel buffer into a newly created Bitmap object which will be returned to the calling code.

Sample Images

The original source Image used to create the sample images in this article has been licensed under the Creative Commons Attribution 2.0 Generic license. The original image is attributed to Luc Viatour and can be downloaded from Wikipedia. Luc Viatour’s website can be viewed at: http://www.lucnix.be

The Original Image

Contrasted Images

C# How to: Image Solarise

Published April 13, 2013 Augmented Reality , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Microsoft , Opensource , Wikipedia 41 Comments
Tags: Alpha Red Green Blue, ARGB, Augmented Reality, Bitmap, Bitmap Filters, Bitmap.LockBits, BitmapData, C#, C# GDI, Graphic Filters, Image Filters, Image Manipulation, Image Solarise, Image Transform, Open source, Opensource, Pixel Filters, Pixel Manipulation

Article Purpose

The focus of this article is set on exploring the concept of Image Solarisation. In this article the tasks required to perform Image Solarisation are entirely implemented on pixel data level. Image manipulation is only implemented in the form of updating the individual Alpha, Red, Green and Blue colour components expressed by Image pixels.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

What is Image Solarisation?

Image Solarisation can be described as a form of Image inversion/colour inversion. A distinction can be made between solarisation and colour inversion when taking into regard threshold values implemented when performing image solarisation.

Colour inversion can be implemented by subtracting each colour component from the value 255 and then assigning the relevant colour component to the result of subtraction. Colour inversion in terms of a formula can be expressed as follows:

R = 255 – R¹

G = 255 – G¹

B = 255 – B¹

In this expression R¹ G² and B¹ represent the original value of a pixel’s Red, Green and Blue colour components prior to being updated. Image Solarisation when expressed as a formula could be represented as follows:

R = R¹

If R¹ < R_T Then R = 255 – R¹

G = G¹

If G¹ < G_T Then G = 255 – G¹

B = B¹

If B¹ < B_T Then B = 255 – B¹

When implementing this expression R¹ G¹ and B¹ represent the original value of a pixel’s Red, Green and Blue colour components prior to being updated. R_T G_T and B_T in this scenario represent configurable threshold values applicable to individual colour components. If a colour component’s original value equates to less than the corresponding threshold value only then should colour inversion be implemented.

Using the sample Application

The concepts discussed in this article are implemented/tested by means of a Windows Forms application. When using the sample application a user has the ability to browse the local file system in order to specify a source/input image. The user interface includes three trackbar controls, each related to a colour component threshold value. Threshold values can range from 0 to 255 inclusive. A threshold value of 0 results in no change, whereas a value of 255 equates to regular colour inversion.

Updated/filtered images can be saved to the local file system at any stage by clicking the ‘Save Image’ button.

The following image is a screenshot of the Image Solarise sample application in action:

The Solarise Extension Method

The sample source code provides the definition for the Solarise extension method. The method has been defined as an extension method targeting the Bitmap class.

The following code snippet details the implementation of the Solarise extension method:

 public static Bitmap Solarise(this Bitmap sourceBitmap, byte blueValue, 
                              byte greenValue, byte redValue) 
{ 
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle  (0, 0, 
                            sourceBitmap.Width, sourceBitmap.Height), 
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

   
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 

   
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 

   
    sourceBitmap.UnlockBits(sourceData); 

   
    byte byte255 = 255; 

   
    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    { 
        if (pixelBuffer[k] < blueValue) 
        { 
             pixelBuffer[k] = (byte)(byte255 - pixelBuffer[k]); 
        }

   
        if (pixelBuffer[k + 1] < greenValue) 
        { 
             pixelBuffer[k + 1] = (byte)(byte255 - pixelBuffer[k + 1]); 
        }

   
        if (pixelBuffer[k + 2] < redValue) 
        {
             pixelBuffer[k + 2] = (byte)(byte255 - pixelBuffer[k + 2]); 
        } 
    } 

   
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 
  
    BitmapData resultData = resultBitmap.LockBits(new Rectangle  (0, 0, 
                             resultBitmap.Width, resultBitmap.Height), 
                             ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

   
    Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

   
    return resultBitmap; 
 }

The next step involves iterating through the byte buffer of colour components. Notice how each iteration modifies an entire pixel by iterating by 4. As discussed earlier when implementing image solarisation the associated formula employs threshold comparison, which determines whether or not colour inversion should be applied.

The final operation performed by the Solarise method involves copying the modified pixel buffer into a newly created Bitmap object which will be returned to the calling code.

Sample Images

The original source image used to create all of the solarised sample images in this article has been licensed under the Creative Commons Attribution-Share Alike 3.0 Unported, 2.5 Generic, 2.0 Generic and 1.0 Generic license. The original image is attributed to Kenneth Dwain Harrelson and can be downloaded from Wikipedia.

The Original Image

Solarised Images

C# How to: Bitmap Colour Shading

Published April 13, 2013 Augmented Reality , Code Samples , Extension Methods , Graphic Filters , Graphics , How to , Image Filters , Microsoft , Opensource , Wikipedia 41 Comments
Tags: Alpha Red Green Blue, ARGB, ARGB Tint, Augmented Reality, Bitmap, Bitmap Filters, Bitmap Shading, Bitmap.LockBits, BitmapData, C#, C# GDI, Graphic Filters, Image Filters, Image Manipulation, Image Transform, Open source, Opensource, Pixel Filters, Pixel Manipulation

Article Purpose

The objective of this article is focussed on exploring the concept of applying Colour Shading to Bitmap images. The various Bitmap manipulation operations detailed in this article are all exclusively implemented by processing raw pixel data. No traditional GDI+ drawing operations are required in implementing Bitmap Colour Shading.

Sample source code

This article is accompanied by a sample source code Visual Studio project which is available for download here.

Using the sample Application

This article has been written from a practical implementation point of view. The concepts detailed throughout this article are all coupled with a corresponding source code implementation. A sample application has been provided with this article. The sample application has been implemented in the architecture of a Windows Forms application, of which a complete source code implementation has also been provided. The sample application facilitates implementing and testing the concepts surrounding Bitmap Colour Shading as discussed in this article.

In using the Bitmap Shading sample application users have the ability to select a source/input image from the local file system. The user interface facilitates implementing Bitmap Colour Shading through three trackbar controls, each associated with a colour component. The value range of each trackbar control is defined from 0 to 100 inclusive. A value of 100 equates to no change and a value of 0 equating to the most possible change.

Users are able to save to the local file system any modified Bitmap images by clicking the ‘Save Image’ button and providing a file path and file name.

The screenshot below illustrates the Bitmap Shading application in action:

The ColorShade Extension method

The ColorShade extension method forms the crux of this article. The ColorShade method has been defined as an extension method targeting the Bitmap class. It is within this method that all raw pixel manipulation occurs. In essence each pixel expressed by the specified Bitmap image will be extracted upon which calculations are performed updating the value of Alpha, Red, Green and Blue colour components.

The following code snippet details the implementation of the ColorShade extension method:

 public static Bitmap ColorShade(this Bitmap sourceBitmap, float blueShade, 
                                float greenShade, float redShade) 
{
    BitmapData sourceData = sourceBitmap.LockBits(new Rectangle(0, 0, 
                            sourceBitmap.Width, sourceBitmap.Height), 
                            ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); 

  
    byte[] pixelBuffer = new byte[sourceData.Stride * sourceData.Height]; 

  
    Marshal.Copy(sourceData.Scan0, pixelBuffer, 0, pixelBuffer.Length); 

  
    sourceBitmap.UnlockBits(sourceData); 

  
    float blue = 0; 
    float green = 0; 
    float red = 0; 

  
    for (int k = 0; k + 4 < pixelBuffer.Length; k += 4) 
    { 
        blue = pixelBuffer[k] * blueShade; 
        green = pixelBuffer[k + 1] * greenShade; 
        red = pixelBuffer[k + 2] * redShade; 

 
        if (blue < 0) 
        { blue = 0; } 

 
        if (green < 0) 
        { green = 0; } 

  
        if (red < 0) 
        { red = 0; } 

  
        pixelBuffer[k] = (byte)blue; 
        pixelBuffer[k + 1] = (byte)green; 
        pixelBuffer[k + 2] = (byte)red; 
    } 

  
    Bitmap resultBitmap = new Bitmap(sourceBitmap.Width, sourceBitmap.Height); 

  
    BitmapData resultData = resultBitmap.LockBits(new Rectangle(0, 0, 
                            resultBitmap.Width, resultBitmap.Height), 
                            ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb); 

  
    Marshal.Copy(pixelBuffer, 0, resultData.Scan0, pixelBuffer.Length); 
    resultBitmap.UnlockBits(resultData); 

  
    return resultBitmap; 
}

The next step involves iterating through the byte buffer of colour components. Notice how each iteration modifies an entire pixel by iterating by 4. The formula being implemented can be expressed as:

R = R¹ * R_S

G = G¹ * G_S

B = B¹ * B_S

In the stated equation R¹ G¹ and B¹ represents the original value of a colour component and R_S G_S and B_S equates to the percentage of shading expressed by each colour component. Take note that in this scenario shading percentages are defined in terms of a fractional value. As an example 45% would result in a shading factor of 0.45.

Sample Images

The original image file used in this article was authored by Konstantin Lanzet and is licensed under the Creative Commons Attribution-Share Alike 3.0 Unported license, and can be downloaded from Wikipedia.

The Original Image

Colour Shaded Images

Posts Tagged 'C# GDI'

Article Purpose

Sample source code

Using the Sample Application

Image Arithmetic

The ArithmeticBlend Extension method

The ColorCalculator.Calculate method

Image Arithmetic: Add

Image Arithmetic: Average

Image Arithmetic: SubtractLeft

Image Arithmetic: SubtractRight

Image Arithmetic: Difference

Image Arithmetic: Multiply

Image Arithmetic: Min

Image Arithmetic: Max

Image Arithmetic: Amplitude

Related Articles

Rate this:

Share this:

Article Purpose

Sample source code

Bitwise Operations

Using the sample Application

The BitwiseBlend Extension method

Sample Images

Related Articles

Rate this:

Share this:

Article Purpose

Sample source code

What is Image Contrast?

Using the sample Application

The Contrast Extension Method

Sample Images

The Original Image

Contrasted Images

Related Articles

Rate this:

Share this:

Article Purpose

Sample source code

What is Image Solarisation?

Using the sample Application

The Solarise Extension Method

Sample Images

The Original Image

Solarised Images

Related Articles

Rate this:

Share this:

Article Purpose

Sample source code

Using the sample Application

The ColorShade Extension method

Sample Images

The Original Image

Colour Shaded Images

Related Articles

Rate this:

Share this:

Dewald Esterhuizen

RSS Feed

Recent Posts

Blog Stats

Follow SoftwareByDefault via Email

Categories

Top Posts & Pages

Archives

C# How to Articles

SoftwareByDefault Online References

MSDN Articles

Categories

Tags