Tips from http://blog.csdn.net/maozefa/article/details/4533770 for image processing with a scan line of GDI + bitmap data

Tips for using GDI + bitmap data scanning lines to process images: C/C ++ 2071 people read comments (4) collect reports

In GDI + image processing, we often use the bitmapdata structure to scan the line of image data. This method is used in most of my Bolg articles. Using its lockbits method and unlockbits method, GDI + bitmap is used to lock (obtain) and unlock (release) bitmapdata data respectively. We generally operate the scanned line of image data between these two methods, for example:

 

[CPP]View plaincopyprint?

1. Bitmap * BMP = new Bitmap (l "d: // 001-1.jpg ");
2. Bitmapdata data;
3. Gdiplus: rect R (0, 0, BMP-> getwidth (), BMP-> getheight ());
4. // The lock is in 32-bit pixel format.
5. BMP-> lockbits (& R, imagelockmoderead | imagelockmodewrite, pixelformat32bppargb, & data );
7. // Scan the image data line here. Many methods cannot be called because BMP is locked.
9. BMP-> unlockbits (& data); // unlock
10. Gdiplus: Graphics * g = new gdiplus: Graphics (canvas-> handle );
11. G-> drawimage (BMP, 0, 0 );
12. Delete g;
13. Delete BMP;

 

Because the bitmap object is locked between the lockbits method and the unlockbits method, many methods cannot be called, and sometimes it is inconvenient or even cumbersome. For example, if you want to display or save the scanned lines of image data multiple times, you have to call these two methods repeatedly; in addition, images with a bitmap format lower than the 24-bit format cannot be locked to 24-bit or 32-bit data for operations (we mostly use 24-bit or 32-bit pixel scanning lines for image processing.

You can use some tips to avoid the inconvenience caused by the locking of Bitmap objects. You can also scan images of 24 or 32 bits or smaller than 24 bits. See the following example:

 

[CPP]View plaincopyprint?

1. Gdiplus: Graphics * g = new gdiplus: Graphics (canvas-> handle );
2. Bitmap * BMP = new Bitmap (l "d: // 001-1.jpg ");
3. Bitmapdata data;
4. Gdiplus: rect R (0, 0, BMP-> getwidth (), BMP-> getheight ());
5. // Pre-set Scan Line Length and Image Data
6. Data. stride = R. Width * 4;
7. Data. scan0 = (void *) New char [R. Height * Data. stride];
8. // Create a 32-bit Custom Data bitmap object
9. Bitmap * BMP 2 = new Bitmap (R. Width, R. Height, Data. stride,
10. Pixelformat32bppargb, (byte *) data. scan0 );
11. // Use the imagelockmoderead tag to copy BMP image data to data. scan0.
12. // Use imagelockmodeuserinputbuf to mark and lock the image BMP so that BMP and BMP 2 Share the image data.
13. // Use the imagelockmodewrite mark to synchronize BMP and BMP 2, that is, when Image Data Processing
14. // Apply to BMP and BMP 2. After imagelockmodewrite is removed, the BMP image remains unchanged,
15. // Remove imagelockmodewrite from images in less than 24 bits.
16. BMP-> lockbits (& R, imagelockmoderead | imagelockmodewrite | imagelockmodeuserinputbuf,
17. Pixelformat32bppargb, & data );
19. // You can perform step-by-step operations on the image scanning line, and also display BMP 2, or call any methods of BMP 2.
20. Imagegray (& data); // grayscale images. The specific process is omitted.
21. G-> drawimage (BMP 2, 0, 0); // draw an image (or call other methods)
22. Imagetwovalues (& Dada, 127); // binarization of images. The specific process is omitted.
23. G-> drawimage (BMP 2, 200, 0); // draw an image (or call other methods)
25. BMP-> unlockbits (& data );
26. Delete g;
27. Delete BMP;
28. Delete BMP 2;
29. Delete [] data. scan0; // must be released

 

The code in the above example is described in detail and will not be explained.

The code in the above example Seems messy to explain the bitmap object sharing and data processing synchronization.Remember: In this example, after the custom bitmap object BMP 2 acquires data through the BMP-> lockbits method, BMP can be unlocked or even deleted without special requirements, in this case, you no longer need to lock BMP 2. You can change the image data contained in BMP 2 by processing the data.

 

Re-plan the code above to make it clearer:

 

[CPP]View plaincopyprint?

1. Bool getbitmapdata (wchar * filename, pixelformat, bitmapdata * Data)
2. {
3. Bitmap * BMP = new Bitmap (filename );
4. If (BMP-> getlaststatus ()! = OK)
5. Return false;
6. Gdiplus: rect R (0, 0, BMP-> getwidth (), BMP-> getheight ());
7. Uint pixelsize = getpixelformatsize (pixelformat );
8. Data-> stride = (pixelsize * R. Width + 31) & 0xffffffe0)> 3;
9. Data-> scan0 = (void *) New char [R. Height * Data-> stride];
10. BMP-> lockbits (& R, imagelockmoderead | imagelockmodeuserinputbuf,
11. Pixelformat, data );
12. BMP-> unlockbits (data );
13. Delete BMP;
14. Return true;
15. }
17. Void _ fastcall tform2: button1click (tobject * sender)
18. {
19. // Obtain the 24-bit pixel data of the image
20. Bitmapdata data;
21. If (! Getbitmapdata (l "d: // 001-1.jpg", pixelformat24bpprgb, & Data ))
22. Return;
23. // Create a user-defined data bitmap object in 24-bit pixel format
24. Bitmap * BMP = new Bitmap (data. Width, Data. Height, Data. stride,
25. Data. pixelformat, (byte *) data. scan0 );
26. Gdiplus: Graphics * g = new gdiplus: Graphics (canvas-> handle );
28. // Scan lines of image data can be operated here, so you do not have to lock BMP, and you can also display BMP, or call any methods of BMP.
29. Imagegray (& data); // grayscale images. The specific process is omitted.
30. G-> drawimage (BMP, 0, 0); // draw an image (or call other methods)
31. Imagetwovalues (& Dada, 127); // binarization of images. The specific process is omitted.
32. G-> drawimage (BMP, 200, 0); // draw an image (or call other methods)
34. Delete g;
35. Delete BMP;
36. Delete [] data. scan0; // must be released
37. }

 

Through the code above, we can see that after getbitmapdata is called, all the image data information is included in the bitmapdata structure, so we can perform any operation on this data structure, instead of relying on any GDI + object, this avoids the inconvenience mentioned above. To create a custom data bitmap object, you only need to use it for image display, storage, and other operations.

 

You can also perform the puzzle operation by using code similar to the previous example:

 

[CPP]View plaincopyprint?

1. Gdiplus: Graphics * g = new gdiplus: Graphics (canvas-> handle );
2. Bitmap * BMP = new Bitmap (l "d: // 001-1.jpg ");
3. Bitmapdata data;
4. Gdiplus: rect R (0, 0, BMP-> getwidth (), BMP-> getheight ());
5. // Pre-set the scanning line length and image data. The scanning line is the width of two images.
6. Data. stride = R. Width * 2*4;
7. Data. scan0 = (void *) New char [R. Height * Data. stride];
9. // Copy the image to the left. Note that only data is read here, So imagelockmodewrite is not used.
10. BMP-> lockbits (& R, imagelockmoderead | imagelockmodeuserinputbuf,
11. Pixelformat32bppargb, & data );
12. BMP-> unlockbits (& data );
14. // Splice the image to the right. to simplify the image, use the same image.
15. // If the image size is different, as long as the size of the r is the same (cannot be larger than the source image)
16. (Char *) data. scan0 + = (R. Width * 4); // The scanned line address moves to the right.
17. BMP-> lockbits (& R, imagelockmoderead | imagelockmodeuserinputbuf,
18. Pixelformat32bppargb, & data );
19. BMP-> unlockbits (& data );
21. (Char *) data. scan0-= (R. Width * 4); // restore the scanned line address
22. Data. width = R. Width * 2; // reset the tile width.
23. // The tiled graph data information is included in data. You can continue to perform any operations on data.
25. // Create a custom data bitmap object
26. Bitmap * BMP 2 = new Bitmap (data. Width, Data. Height, Data. stride,
27. Data. pixelformat, (byte *) data. scan0 );
28. // Display the spliced image.
29. G-> drawimage (BMP 2, 0, 0 );
30. Delete g;
31. Delete BMP;
32. Delete BMP 2;
33. Delete [] data. scan0; // must be released

 

The code in this article uses the BCB compiler. If there is an error, you can send a letter to correct, and please make suggestions: maozefa@hotmail.com