Rotate a bitmap image

If you are targeting your application for Windows NT alone, then you have access to API functions to help you rotate the bitmap. You can either use world transformation and BitBlt() or use PlgBlt() for rotating the bitmap. A function using the first combination is shown below.

If you are targeting multiple platforms, then your task becomes tougher. You could either rotate each pixel in the source bitmap one at a time or directly manipulate the DIB bits to get the rotated bitmap. The first method is very slow to the point of being useless and the second is more complex but is fast enough. We cover both these methods below. Note that all the functions shown below create a new bitmap ( in one case it creates a DIB ). If instead of a new bitmap you want the rotated image to be drawn directly, you will need to modify the functions.
Function 1: GetRotatedBitmapNT()
This function is specific to NT and will not work on Windows95. It's the simplest and probably the fastest of the three functions listed in this topic. The other two functions share some of the same initial code.

All the three functions expect the angle of rotation to be in radians. If you have degrees to begin with you can convert from degrees to radians by using the formula

radian = (2*pi *degree)/360

Here are the steps that we take to rotate the bitmap.

Create a couple of device contexts compatible with the display. One of them will be used to hold the source bitmap and the other will hold the destination bitmap (for the rotated image).

Precompute the cosine and the sine of the angle. This will help save a few microseconds in subsequent computations.

Compute the bounding rectangle of the rotated image. We use the formula
newx = x.cos(angle) + y.sin(angle)
newy = y.cos(angle) - x.sin(angle)We assume one of the corners (0,0) to be the center of rotation and therefore need to calculate the new co-ordinates of the other three corners. Based on this we can determine the widht and height of the new bitmap.

Since the rotated image will not occupy the entire area of the new bitmap, we fill the destination bitmap with the background color specified through the function argument.

Since we will use NTs support for linear transformation we set the graphic mode of the destination DC to support this.

We set up the XFORM struction and call SetWorldTransform() to activate the transformation. The SetWorldTransform() function sets up the stage for BitBlt(), which is when the transformation takes place. The algorithm used for the linear transformation is
newx = x * eM11 + y * eM21 + eDx
newy = x * eM12 + y * eM22 + eDyFor rotation eM11 and eM22 should be the cosine of the rotation angle, eM12 should be the sine of the rotation angle and eM21 should be -eM12. In the DC we are using, since the +ve y direction is downwards, we reverse the signs of eM12 and eM21. We also set the translation components (eDx & eDy) so that rotated image fits inside the new bitmap without part of it getting clipped.

We finally call BitBlt() to do the actual rotation. This call in itself looks like it will simply copy the image. However, the previous call to SetWorldTransform() causes the image to be rotated.

Function 2: GetRotatedBitmap() using GetPixel & SetPixel

This function is more for education purpose. It does work but it takes a few seconds to finish. It might even be useful for very small bitmaps.

Here's what the function does:

Create a couple of device contexts to work with.

Computes the bounding rectangle of the rotated image and fills it with the background color.

We set the mapping mode in both the device contexts so that the +ve direction of the y-axis goes up. We also set the origin in the destination DC to the point that would coincide with the point (0,0) in the source DC. This is simply to make our computation somewhat simpler.

We traverse through each pixel in the destination bitmap and compute which pixel, if any, from the source bitmap corresponds to it. This is somewhat unusual. You would expect to traverse the source pixels and copy it to its proper place in the destination bitmap. Although, this would be a more straight forward approach, it doesn't work right. The problem is that it leaves a few gaps in the destination bitmap. Reversing the transformation fixes this problem.

Function 3: GetRotatedBitmap() using DIB

This function works on the same principle as the previous function. Unlike the previous function this function is usable and works directly on the bits of the device-independent bitmap. Most of the complexity of this function is due to the fact that DIBs are organized differently depending on the number of colors it uses.

There are two main attributes of a DIB that affect the flow of control in this function. The first is the number of bits used to specify a pixel. This affects how the color information is read and written. The second attribute is the compression. This function does not support run length encoded DIBs. The two compression flags handled are the BI_RGB and BI_BITFIELD. These flags affect how we compute the start of the bitmap bits. The BI_BITFIELD is valid only when the bits per pixel (BPP) is more than 8. This indicates that immediately after the BITMAPINFOHEADER are three double word values which represent a bitmask for the red, green and blue colors. The first of the double word mask is for red.

After computing the size of the new DIB we allocate space for a new bitmap and initialize it with values from the source DIB. The widht and height of course is set to new values. We then set the background color for the new DIB to the specified value. Actually we set the color only when the BPP is 8 or less, otherwise we simply compute a color value specific to the DIB and save it for later use. If the bits per pixel is 4 or 8, we scan through the color table to find a match for the supplied background color. If we find the color, we set this index for all the pixels in the bitmap otherwise we let the color remain black. For bitmaps with 16 or more bits per pixel we create a 16, 24 or 32 bit value that will represent the color. We only use those color masks that is supported by both Windows 95 and NT.

The actual rotation involves using a reverse transform. That is, for each destination pixel we determine the source pixel that should be copied there. As I've noted while discussing the previous function, the reason for this is that the straight transform will leave small blank spots. The main stuff here is getting and setting the color information. When dealing with monochrome bitmaps, each bit represents a pixel. The most significant bit in a byte is the left most pixel. This explains the expression (0x80 >> x%8) which gives us the bit position of the given pixel. Since we are dealing with bits, we have to first clear out the relevant bit in the destination bitmap before using the OR operation to set it to the new value. Note that the bit position in the source and the bit position in the destination bitmaps are likely to be different.

For bitmaps with 4 bits per pixel, we again have to deal with bitmasks. In this case the 4 most significant bits specify the pixel on the left. When the bits per pixel is 8, 16, 24 or 32 we copy 1,2,3 and 4 bytes respectively. Also, when the bits per pixel is more than 8 and the destination pixel does not correspond to any of the source pixel, then we set it to the background color.

Bug found in Function 2: GetRotatedBitmap() using GetPixel & SetPixel

I was able to verify that using this method would cause a rotated bitmap image to clipped at the bottom raster. In order to fixed the problem i have updated/modified the code that sets the viewport origin of the destination DC.

Top White Papers and Webcasts

Migrating away from Windows Server 2003 is an investment in your organization's future, and there has never been a better time to begin the migration process. Take the next step to transform your datacenter by upgrading your server platform with leading edge Windows Operating Systems and SanDisk flash solutions.

As virtualization becomes the norm throughout organizations of nearly all sizes, and as more organizations look to private cloud solutions, IT decision makers are increasingly in need of ways to keep storage costs and complexity under control in the face of often-runaway virtual machine (VM) sprawl. Application-aware storage is designed to help achieve these important goals. Read this white paper to learn how application-aware storage allows you to gain VM-level visibility into application performance and …