Application of GDI + in Delphi-brightness adjustment of imitation Photoshop

Over the past few days, I have studied Photoshop's color phase/saturation command, which is the so-called HSB color mode. I didn't fully understand it, and I did not have any online search results, I have read some articles about the HSB algorithm, but they actually talk about the HSV or HSL algorithm.

We don't need to study the color phases in PS/saturation. The principle is the same as that in HSV or hsl h.

The effect of saturation at the three points of-100, 0, and + 100 is exactly the same as that of HSL. The other ranges are different, especially in the range of 0 -- +, the adjustment time is smoother than the H adjustment of HSL, so the effective adjustment range is large, some images are imperceptible and distorted when they are adjusted to more than 50% (here, the "distortion" is for the ugly spots in the color, not to say that the whole picture is not distorted ), however, it is difficult to see the positive adjustment of HSL h by more than 10%. It is not the same as HSV. It can be seen that the color phase/saturation algorithm of PS should be improved based on HSL.

The most confusing thing is the brightness adjustment of PS, which seems to be "independent" from the color saturation. We know that to adjust V or L in HSV or HSL mode in a program, we usually need to Convert RGB to HSV or HSL first, or at least separate the V or l parts, after modification, convert it to RGB mode (see my article "Application of GDI + in Delphi Program-linear adjustment of image brightness" to separate the L part of HSL to adjust the brightness ), the brightness adjustment of PS is different. You do not need to Convert RGB to the so-called HSB for adjustment. You can simply write a function, please refer to the following Delphi process and test code (using the tgpbitmap of GDI + and the tbitmap test of Delphi respectively) to simulate the PS brightness adjustment (strictly speaking, it is not called imitation, but the actual PS brightness adjustment process ):

 

Note: In order to unify the data types and image processing formats used in the "Application of GDI + in Delphi" series of articles, the code in this article has been revised, for details about the gdiplus unit and bug correction used in the code, see the article "GDI + for VCL basics-GDI + and VCL". (8.8.18)

Data Type:

1. Type
2. // Image data structure compatible with the GDI + tbitmapdata Structure
3. Timagedata = packed record
4. Width: longword; // The image width.
5. Height: longword; // Image Height
6. Stride: longword; // The length of the scanned line of the image in bytes.
7. Pixelformat: longword; // unused
8. Scan0: pointer; // image data address
9. Reserved: longword; // Reserved
10. End;
11. Pimagedata = ^ timagedata;
13. // Obtain the timagedata data structure of the tbitmap image to facilitate the processing of the tbitmap Image
14. Function getimagedata (BMP: tbitmap): timagedata;
15. Begin
16. BMP. pixelformat: = pf32bit;
17. Result. Width: = BMP. width;
18. Result. Height: = BMP. height;
19. Result. scan0: = BMP. scanline [BMP. Height-1];
20. Result. stride: = result. Width SHL 2;
21. // Result. stride: = (32 * BMP. width) + 31) and $ ffffffe0) SHR 3;
22. End;

Process Code:

1. // Adjust the image brightness
2. Procedure psbrightness (data: timagedata; Value: integer );
3. ASM
4. Push EBP
5. Push ESI
6. Push EDI
7. Push EBX
9. MoV EDI, [eax + 16] // EDI = data. scan0
10. MoV EBP, [eax + 4] // EDP = data. Height * Data. Width
11. Imul EBP, [eax]
12. MoV ESI, EDX // ESI = Value
13. MoV EBX, 255 // EBX = 255
14. ClD
15. @ Pixelloop: // for (I = EBP; I> 0; I --)
16. MoV ECx, 3 //{
17. @ Vloop: // For (j = 3; j> 0; j --)
18. Movzx eax, [EDI] // {
19. Push eax
20. Test ESI, ESI
21. JS @ 1
22. Neg eax // If (value> 0)
23. Add eax, EBX // RGB = RGB + (255-RGB) * value/255
24. @ 1:
25. Imul eax, ESI // else
26. CDQ // RGB = RGB + RGB * value/255
27. Idiv EBX
28. Pop edX
29. Add eax, EDX
30. JNS @ 2 // RGB = max (0, min (255, RGB ))
31. XOR eax, eax
32. JMP @ 3
33. @ 2:
34. CMP eax, EBX
35. Jle @ 3
36. MoV eax, EBX
37. @ 3:
38. Stosb // * EDI ++ = RGB
39. Loop @ vloop //}
40. Inc edi // EDI ++
41. Dec EBP
42. Jnz @ pixelloop //}
44. Pop EBX
45. Pop EDI
46. Pop ESI
47. Pop EBP
48. End;
50. // Adjust the brightness of the GDI + image
51. Procedure gdippsbrightness (BMP: tgpbitmap; Value: integer );
52. VaR
53. Data: tbitmapdata;
54. Begin
55. If value = 0 Then exit;
56. Data: = BMP. lockbits (gprect (0, 0, BMP. Width, BMP. Height), [imread, imwrite], pf32bppargb );
57. Try
58. Psbrightness (timagedata (data), value );
59. Finally
60. BMP. unlockbits (data );
61. End;
62. End;
64. // Adjust the brightness of the tbitmap Image
65. Procedure bitmappsbrightness (BMP: tbitmap; Value: integer );
66. Begin
67. If value <> 0 then
68. Hslbrightness (getimagedata (BMP), value );
69. End;

We can see that the above psbrightness process does not rely on any color mode conversion, but uses the following pseudocode formula:

If (value> = 0)
RGB = RGB + (255-RGB) * value/255;
Else
RGB = RGB + RGB * value/255;

Here, RGB represents the R, G, and B colors respectively, and the value is the brightness value. What is the meaning of this formula? It is actually the deformation of the formula for converting HSL to the L part of RGB, the formula I used in "Application of GDI + in Delphi Program-linear adjustment of image brightness" is the same as that in its form, except that the calculation base is different:

L = L-128;
If (L> = 0)
RGB = RGB + (255-RGB) * l/128;
Else
RGB = RGB + RGB * l/128;

The former uses the full range of value 255 or 100% (the/255 after the formula is changed to/100), while the latter uses the 1/2 of L, that is, 128 or 50% (in this case, the effect is quite different), and to adjust the brightness by using L, you must obtain L from the HSL space and add the adjusted value, the PS brightness adjustment does not need to get the original B from HSB, which means that B is always "0" in HSB "! Although the brightness adjustment of PS is put together with the color phase/saturation adjustment, it is completely independent of the color phase/saturation, which is why I feel like it is "independent, it is also an important reason for the study of the failure of the PS saturation algorithm (a B = 0 HSB mode, how to correctly convert the HS part to R, G, B? You need to know that the L in the V and HSL of HSV is crucial in the correct conversion to the RGB mode !).

If my feeling is correct, what is the principle of Ps "independent" brightness adjustment? We know that the general non-linear RGB brightness adjustment is only achieved by adding and reducing a certain amount based on the original R, G, and B values, the brightness adjustment principle of PS must be found from the previous formula. We will adjust the positive brightness formula: RGB = RGB + (255-RGB) * value/255 to RGB = (RGB * (255-value) + 255 * value)/255, if the value represents the maximum value of 255 with 1, it is RGB = RGB * (1-value) + 255 * value. what can be seen? Anyone who knows about image synthesis knows this formula. In fact, the brightness adjustment of PS adopts the Alpha synthesis method. Here the value is Alpha, and the first part of the formula is RGB * (1-value) the image part is followed by the 255 * value part, which is a white shadow layer. The greater the brightness, the greater the Alpha of the Shadow layer, the more the image is discussed, and vice versa. The negative adjustment of brightness is done by a black shadow layer. Negative 100% is all black. The full picture is displayed only when alpha = 0, or the brightness value is 0. It is easy to verify the above statement. One is to run my test code, but to overwrite an image with a full white or black layer in PS, and adjust the opacity of this layer, it can be seen that the effect is exactly the same as that of brightness adjustment!

In fact, I am only interested in the adjustment of the saturation of PS, because we have already said that the effect is better than that of the adjustment of the saturation of HSV and HSL, the range is large, and the saturation algorithm has not been studied, then we made a brightness adjustment process. I am not very grateful to anyone who want to know the PS saturation algorithm!

 

Test code:

2. Procedure tform1.button1click (Sender: tobject );
3. VaR
4. Image: tgpbitmap;
5. G: tgpgraphics;
6. Begin
7. Image: = tgpbitmap. Create ('d:/vcllib/gdiplusdemo/Media/20041001.jpg ');
8. G: = tgpgraphics. Create (handle, false );
9. G. drawimage (image, 10, 10 );
10. Gdippsbrightness (image, 30 );
11. G. drawimage (images, 10,220 );
12. Image. Free;
13. G. Free;
14. End;
16. Procedure tform1.button2click (Sender: tobject );
17. VaR
18. Image: tbitmap;
19. Begin
20. Image: = tbitmap. Create;
21. Image. loadfromfile ('d:/vcllib/gdiplusdemo/Media/20041001.bmp ');
22. Canvas. Draw (10, 10, image );
23. Bitmappsbrightness (image,-30 );
24. Canvas. Draw (10,220, image );
25. Image. Free;
26. End;

If there is an error please send a letter to correct: maozefa@hotmail.com