ToB企服应用市场:ToB评测及商务社交产业平台

标题: 高效编写C#图像处理程序(3) Rgb=>Lab，图像缺陷检测的案例 [打印本页]

---

作者: 灌篮少年    时间: 2022-9-5 02:54
标题: 高效编写C#图像处理程序(3) Rgb=>Lab，图像缺陷检测的案例
大家好，有没有朋友最近项目需要检测图像是否存在​​偏色​​、过亮、模糊等缺陷。由于主要用在视频监控上，对性能要求比较高。有几项检测必须要在Lab彩色下进行，而众所周知Rgb => Lab 计算量较大，C#搞得定搞不定？测试表明，用纯C#编写的Rgb => Lab代码在性能上与C编写的Rgb => Lab代码极为接近。
1. Rgb24和Lab24

Rgb是电脑上使用较多的彩色空间，Lab是针对人的感知设计的均匀彩色空间，很多情况下进行彩色图像分析，需要在Rgb彩色空间和Lab彩色空间之间进行转化。关于Lab彩色空间的详细介绍和Rgb空间与Lab空间的转换公式见维基百科的对应词条 ​​Lab色彩空间​​，本文不再叙述。
使用Rgb24和Lab24两个struct定义Rgb彩色空间的像素和Lab彩色空间的像素。
 
Rgb24 与 Lab24

1. 1 public partial struct Rgb24  <br>2 {  <br>3     public static Rgb24 WHITE = new Rgb24 { Red = 255, Green = 255, Blue = 255 };  <br>4     public static Rgb24 BLACK = new Rgb24();  <br>5     public static Rgb24 RED = new Rgb24 { Red = 255 };  <br>6     public static Rgb24 BLUE = new Rgb24 { Blue = 255 };  <br>7     public static Rgb24 GREEN = new Rgb24 { Green = 255 };  <br>8           <br>9     [FieldOffset(0)]  <br>10     public Byte Blue;  <br>11     [FieldOffset(1)]  <br>12     public Byte Green;  <br>13     [FieldOffset(2)]  <br>14     public Byte Red;  <br>15           <br>16     public Rgb24(int red, int green, int blue)  <br>17     {  <br>18         Red = (byte)red;  <br>19         Green = (byte)green;  <br>20         Blue = (byte)blue;  <br>21     }  <br>22           <br>23     public Rgb24(byte red, byte green, byte blue)  <br>24     {  <br>25         Red = red;  <br>26         Green = green;  <br>27         Blue = blue;  <br>28     }  <br>29 }          <br>30           <br>31 public partial struct Lab24  <br>32 {  <br>33     public byte L;  <br>34     public byte A;  <br>35     public byte B;  <br>36           <br>37     public Lab24(byte l,byte a,byte b)  <br>38     {  <br>39         L = l;  <br>40         A = a;  <br>41         B = b;  <br>42     }  <br>43           <br>44     public Lab24(int l,int a,int b)  <br>45     {  <br>46         L = (byte)l;  <br>47         A = (byte)a;  <br>48         B = (byte)b;  <br>49     }  <br>50 }

复制代码

 
 
Lab空间参照OpenCV，用一个byte来表示Lab空间的每个通道值，以求提高性能。由于标准的Lab空间中a和b通道是可付的，Lab24中的A、B值减去128，就是标准Lab空间的a，b通道值。
2. Rgb24  Lab24 的实现

OpenCV中BgrLab是用C语言实现的，下面将它转换为C#代码：
 

1. Rgb24 <=> Lab24     <br>  1 public sealed class UnmanagedImageConverter  <br>  2 {  <br>  3     /* 1024*(([0..511]./255)**(1./3)) */  <br>  4     static ushort[] icvLabCubeRootTab = new ushort[] {  <br>  5     0,161,203,232,256,276,293,308,322,335,347,359,369,379,389,398,  <br>  6     406,415,423,430,438,445,452,459,465,472,478,484,490,496,501,507,  <br>  7     512,517,523,528,533,538,542,547,552,556,561,565,570,574,578,582,  <br>  8     586,590,594,598,602,606,610,614,617,621,625,628,632,635,639,642,  <br>  9     645,649,652,655,659,662,665,668,671,674,677,680,684,686,689,692,  <br>10     695,698,701,704,707,710,712,715,718,720,723,726,728,731,734,736,  <br>11     739,741,744,747,749,752,754,756,759,761,764,766,769,771,773,776,  <br>12     778,780,782,785,787,789,792,794,796,798,800,803,805,807,809,811,  <br>13     813,815,818,820,822,824,826,828,830,832,834,836,838,840,842,844,  <br>14     846,848,850,852,854,856,857,859,861,863,865,867,869,871,872,874,  <br>15     876,878,880,882,883,885,887,889,891,892,894,896,898,899,901,903,  <br>16     904,906,908,910,911,913,915,916,918,920,921,923,925,926,928,929,  <br>17     931,933,934,936,938,939,941,942,944,945,947,949,950,952,953,955,  <br>18     956,958,959,961,962,964,965,967,968,970,971,973,974,976,977,979,  <br>19     980,982,983,985,986,987,989,990,992,993,995,996,997,999,1000,1002,  <br>20     1003,1004,1006,1007,1009,1010,1011,1013,1014,1015,1017,1018,1019,1021,1022,1024,  <br>21     1025,1026,1028,1029,1030,1031,1033,1034,1035,1037,1038,1039,1041,1042,1043,1044,  <br>22     1046,1047,1048,1050,1051,1052,1053,1055,1056,1057,1058,1060,1061,1062,1063,1065,  <br>23     1066,1067,1068,1070,1071,1072,1073,1074,1076,1077,1078,1079,1081,1082,1083,1084,  <br>24     1085,1086,1088,1089,1090,1091,1092,1094,1095,1096,1097,1098,1099,1101,1102,1103,  <br>25     1104,1105,1106,1107,1109,1110,1111,1112,1113,1114,1115,1117,1118,1119,1120,1121,  <br>26     1122,1123,1124,1125,1127,1128,1129,1130,1131,1132,1133,1134,1135,1136,1138,1139,  <br>27     1140,1141,1142,1143,1144,1145,1146,1147,1148,1149,1150,1151,1152,1154,1155,1156,  <br>28     1157,1158,1159,1160,1161,1162,1163,1164,1165,1166,1167,1168,1169,1170,1171,1172,  <br>29     1173,1174,1175,1176,1177,1178,1179,1180,1181,1182,1183,1184,1185,1186,1187,1188,  <br>30     1189,1190,1191,1192,1193,1194,1195,1196,1197,1198,1199,1200,1201,1202,1203,1204,  <br>31     1205,1206,1207,1208,1209,1210,1211,1212,1213,1214,1215,1215,1216,1217,1218,1219,  <br>32     1220,1221,1222,1223,1224,1225,1226,1227,1228,1229,1230,1230,1231,1232,1233,1234,  <br>33     1235,1236,1237,1238,1239,1240,1241,1242,1242,1243,1244,1245,1246,1247,1248,1249,  <br>34     1250,1251,1251,1252,1253,1254,1255,1256,1257,1258,1259,1259,1260,1261,1262,1263,  <br>35     1264,1265,1266,1266,1267,1268,1269,1270,1271,1272,1273,1273,1274,1275,1276,1277,  <br>36     1278,1279,1279,1280,1281,1282,1283,1284,1285,1285,1286,1287,1288,1289,1290,1291  <br>37     };  <br>38           <br>39     const float labXr_32f = 0.433953f /* = xyzXr_32f / 0.950456 */;  <br>40     const float labXg_32f = 0.376219f /* = xyzXg_32f / 0.950456 */;  <br>41     const float labXb_32f = 0.189828f /* = xyzXb_32f / 0.950456 */;  <br>42           <br>43     const float labYr_32f = 0.212671f /* = xyzYr_32f */;  <br>44     const float labYg_32f = 0.715160f /* = xyzYg_32f */;  <br>45     const float labYb_32f = 0.072169f /* = xyzYb_32f */;  <br>46           <br>47     const float labZr_32f = 0.017758f /* = xyzZr_32f / 1.088754 */;  <br>48     const float labZg_32f = 0.109477f /* = xyzZg_32f / 1.088754 */;  <br>49     const float labZb_32f = 0.872766f /* = xyzZb_32f / 1.088754 */;  <br>50           <br>51     const float labRx_32f = 3.0799327f  /* = xyzRx_32f * 0.950456 */;  <br>52     const float labRy_32f = (-1.53715f) /* = xyzRy_32f */;  <br>53     const float labRz_32f = (-0.542782f)/* = xyzRz_32f * 1.088754 */;  <br>54           <br>55     const float labGx_32f = (-0.921235f)/* = xyzGx_32f * 0.950456 */;  <br>56     const float labGy_32f = 1.875991f   /* = xyzGy_32f */ ;  <br>57     const float labGz_32f = 0.04524426f /* = xyzGz_32f * 1.088754 */;  <br>58           <br>59     const float labBx_32f = 0.0528909755f /* = xyzBx_32f * 0.950456 */;  <br>60     const float labBy_32f = (-0.204043f)  /* = xyzBy_32f */;  <br>61     const float labBz_32f = 1.15115158f   /* = xyzBz_32f * 1.088754 */;  <br>62           <br>63     const float labT_32f = 0.008856f;  <br>64           <br>65     const int lab_shift = 10;  <br>66           <br>67     const float labLScale2_32f = 903.3f;  <br>68           <br>69     const int labXr = (int)((labXr_32f) * (1 << (lab_shift)) + 0.5);  <br>70     const int labXg = (int)((labXg_32f) * (1 << (lab_shift)) + 0.5);  <br>71     const int labXb = (int)((labXb_32f) * (1 << (lab_shift)) + 0.5);  <br>72           <br>73     const int labYr = (int)((labYr_32f) * (1 << (lab_shift)) + 0.5);  <br>74     const int labYg = (int)((labYg_32f) * (1 << (lab_shift)) + 0.5);  <br>75     const int labYb = (int)((labYb_32f) * (1 << (lab_shift)) + 0.5);  <br>76           <br>77     const int labZr = (int)((labZr_32f) * (1 << (lab_shift)) + 0.5);  <br>78     const int labZg = (int)((labZg_32f) * (1 << (lab_shift)) + 0.5);  <br>79     const int labZb = (int)((labZb_32f) * (1 << (lab_shift)) + 0.5);  <br>80           <br>81     const float labLScale_32f = 116.0f;  <br>82     const float labLShift_32f = 16.0f;  <br>83           <br>84     const int labSmallScale = (int)((31.27 /* labSmallScale_32f*(1<<lab_shift)/255 */ ) * (1 << (lab_shift)) + 0.5);  <br>85           <br>86     const int labSmallShift = (int)((141.24138 /* labSmallScale_32f*(1<<lab) */ ) * (1 << (lab_shift)) + 0.5);  <br>87           <br>88     const int labT = (int)((labT_32f * 255) * (1 << (lab_shift)) + 0.5);  <br>89           <br>90     const int labLScale = (int)((295.8) * (1 << (lab_shift)) + 0.5);  <br>91     const int labLShift = (int)((41779.2) * (1 << (lab_shift)) + 0.5);  <br>92     const int labLScale2 = (int)((labLScale2_32f * 0.01) * (1 << (lab_shift)) + 0.5);  <br>93           <br>94     public static unsafe void ToLab24(Rgb24* from, Lab24* to)  <br>95     {  <br>96         ToLab24(from,to,1);  <br>97     }  <br>98           <br>99     public static unsafe void ToLab24(Rgb24* from, Lab24* to, int length)  <br>100     {  <br>101         // 使用 OpenCV 中的算法实现          <br>102           <br>103         if (length < 1) return;  <br>104           <br>105         Rgb24* end = from + length;  <br>106           <br>107         int x, y, z;  <br>108         int l, a, b;  <br>109         bool flag;  <br>110           <br>111         while (from != end)  <br>112         {  <br>113             Byte red = from->Red;  <br>114             Byte green = from->Green;  <br>115             Byte blue = from->Blue;  <br>116           <br>117             x = blue * labXb + green * labXg + red * labXr;  <br>118             y = blue * labYb + green * labYg + red * labYr;  <br>119             z = blue * labZb + green * labZg + red * labZr;  <br>120           <br>121             flag = x > labT;  <br>122           <br>123             x = (((x) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>124           <br>125             if (flag)  <br>126                 x = icvLabCubeRootTab[x];  <br>127             else  <br>128                 x = (((x * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>129           <br>130             flag = z > labT;  <br>131             z = (((z) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>132           <br>133             if (flag == true)  <br>134                 z = icvLabCubeRootTab[z];  <br>135             else  <br>136                 z = (((z * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>137           <br>138             flag = y > labT;  <br>139             y = (((y) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>140           <br>141             if (flag == true)  <br>142             {  <br>143                 y = icvLabCubeRootTab[y];  <br>144                 l = (((y * labLScale - labLShift) + (1 << ((2 * lab_shift) - 1))) >> (2 * lab_shift));  <br>145             }  <br>146             else  <br>147             {  <br>148                 l = (((y * labLScale2) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>149                 y = (((y * labSmallScale + labSmallShift) + (1 << ((lab_shift) - 1))) >> (lab_shift));  <br>150             }  <br>151           <br>152             a = (((500 * (x - y)) + (1 << ((lab_shift) - 1))) >> (lab_shift)) + 129;  <br>153             b = (((200 * (y - z)) + (1 << ((lab_shift) - 1))) >> (lab_shift)) + 128;  <br>154           <br>155             l = l > 255 ? 255 : l < 0 ? 0 : l;  <br>156             a = a > 255 ? 255 : a < 0 ? 0 : a;  <br>157             b = b > 255 ? 255 : b < 0 ? 0 : b;  <br>158           <br>159             to->L = (byte)l;  <br>160             to->A = (byte)a;  <br>161             to->B = (byte)b;  <br>162           <br>163             from++;  <br>164             to++;  <br>165         }  <br>166     }  <br>167           <br>168     public static unsafe void ToRgb24(Lab24* from, Rgb24* to)  <br>169     {  <br>170         ToRgb24(from,to,1);  <br>171     }  <br>172           <br>173     public static unsafe void ToRgb24(Lab24* from, Rgb24* to, int length)  <br>174     {  <br>175         if (length < 1) return;  <br>176           <br>177         // 使用 OpenCV 中的算法实现          <br>178         const float coeff0 = 0.39215686274509809f;  <br>179         const float coeff1 = 0.0f;  <br>180         const float coeff2 = 1.0f;  <br>181         const float coeff3 = (-128.0f);  <br>182         const float coeff4 = 1.0f;  <br>183         const float coeff5 = (-128.0f);  <br>184           <br>185         if (length < 1) return;  <br>186           <br>187         Lab24* end = from + length;  <br>188         float x, y, z,l,a,b;  <br>189         int blue, green, red;  <br>190           <br>191         while (from != end)  <br>192         {  <br>193             l = from->L * coeff0 + coeff1;  <br>194             a = from->A * coeff2 + coeff3;  <br>195             b = from->B * coeff4 + coeff5;  <br>196           <br>197             l = (l + labLShift_32f) * (1.0f / labLScale_32f);  <br>198             x = (l + a * 0.002f);  <br>199             z = (l - b * 0.005f);  <br>200           <br>201             y = l * l * l;  <br>202             x = x * x * x;  <br>203             z = z * z * z;  <br>204           <br>205             blue = (int)((x * labBx_32f + y * labBy_32f + z * labBz_32f) * 255 + 0.5);  <br>206             green = (int)((x * labGx_32f + y * labGy_32f + z * labGz_32f) * 255 + 0.5);  <br>207             red = (int)((x * labRx_32f + y * labRy_32f + z * labRz_32f) * 255 + 0.5);  <br>208           <br>209             red = red < 0 ? 0 : red > 255 ? 255 : red;  <br>210             green = green < 0 ? 0 : green > 255 ? 255 : green;  <br>211             blue = blue < 0 ? 0 : blue > 255 ? 255 : blue;  <br>212           <br>213             to->Red = (byte)red;  <br>214             to->Green = (byte)green;  <br>215             to->Blue = (byte)blue;  <br>216           <br>217             from++;  <br>218             to++;  <br>219         }  <br>220     }  <br>221 }

复制代码

 
 
由于C代码中使用了宏，在改写成C#代码时需要手动内联，以提高性能。上面的代码已经实现手动内联。
3. (A)C#实现与(B)C实现的性能对比（C# vs. OpenCV/PInvoke）

C# 版本（ImageRgb24 代表一幅Rgb24图像，ImageLab24代表一幅Lab24图像，它们之间的变化是调用上文UnmanagedImageConverter中的方法实现的）例如：进口气动球阀

Stopwatch sw = new Stopwatch();
sw.Start();      
ImageLab24 imgLab = null;      
imgLab = new ImageLab24(img);  // img 是一个 ImageRgb24 对象      
sw.Stop();      
Message = sw.ElapsedMilliseconds.ToString();

OpenCV版本（使用EmguCV对OpenCV的PInvoke封装）

private Image TestOpenCV()      
{      
    Image imgBgr = new Image(imgMain.Image as Bitmap);      
    Image imgLab = new Image(new Size(imgBgr.Width, imgBgr.Height));      
    Stopwatch sw = new Stopwatch();      
    sw.Start();      
    CvInvoke.cvCvtColor(imgBgr.Ptr,imgLab.Ptr, Emgu.CV.CvEnum.COLOR_CONVERSION.CV_BGR2Lab);      
    sw.Stop();      
    MessageBox.Show(sw.ElapsedMilliseconds.ToString() + "ms");      
    return imgLab;      
}

下面针对三副不同大小的图像进行测试，每张图像测试4次，每次测试将上面两种实现各跑一次，前2次，先跑OpenCV/PInvoke实现，后2次，先跑C#实现，单位皆为ms。

图像1，大小：485×342
A: 5    3    5   3      
B: 41   5    6   2
图像2，大小：1845×611
A：25  23    23   23  
B：23  34    20   21  
图像3，大小：3888×2592
A：209  210  211  210      
B：185  188  191  185

从测试结果可以看出，C# 和 OpenCV/PInvoke的性能极为接近。
4. 进一步改进性能

偏色、高光检测等不需要多么准确的Rgb=>Lab转换。如果把彩色图像的每个通道用4 bit来表示，则一共有 4096 种颜色，完全可以用查表方式来加速计算。用一个Lab24数组来表示Rgb24到Lab24空间的映射：

Lab24[] ColorMap

首先初始化ColorMap：

ColorMap = new Lab24[4096];      
for (int r = 0; r < 16; r++)      
{      
    for (int g = 0; g < 16; g++)      
    {      
        for (int b = 0; b < 16; b++)      
        {      
            Rgb24 rgb = new Rgb24(r * 16, g * 16, b * 16);      
            Lab24 lab = Lab24.CreateFrom(rgb);      
            ColorMap[(r  4) > 4) > 4) ];      
        rgbStart++;      
        labStart++;      
    }      
    return lab;      
}

下面测试（C）查表计算的性能，结果和(A)C#实现与(B)C实现放在一起做对比。

图像1，大小：485×342
A: 5    3    5   3      
B: 41   5    6   2      
C: 3    2    2    2
图像2，大小：1845×611
A：25  23    23   23  
B：23  34    20   21  
C:  15   15   15   15
图像3，大小：3888×2592
A：209  210  211  210      
B：185  188  191  185      
C:  136  134  135  135

5. 原地进行变换

还可以进一步提高性能，因为Rgb24和Lab24大小一样，可以在原地进行Rgb24=>Lab24的变换。相应代码如下：

Rgb24[] ColorMapInSpace      
...           
ColorMap = new Lab24[4096];      
ColorMapInSpace = new Rgb24[4096];      
for (int r = 0; r < 16; r++)      
{      
    for (int g = 0; g < 16; g++)      
    {      
        for (int b = 0; b < 16; b++)      
        {      
            Rgb24 rgb = new Rgb24(r * 16, g * 16, b * 16);      
            Lab24 lab = Lab24.CreateFrom(rgb);      
            ColorMap[(r  4)];      
        rgbStart++;      
    }      
}

下面测试D（原地查表变换）的性能，结果和(A)C#实现、(B)C实现、(C)查表计算进行比较：

图像1，大小：485×342
A: 5    3    5   3      
B: 41   5    6   2      
C: 3    2    2    2      
D: 2    1    2    1
图像2，大小：1845×611
A：25  23    23   23  
B：23  34    20   21  
C:  15   15   15   15 
D:  13   13   13   13
图像3，大小：3888×2592
A：209  210  211  210      
B：185  188  191  185      
C:  136  134  135  135      
D:  117  118  122  117

6. 为什么用C#而不是C/C++

经常有人问，你为什么用C#而不用C/C++写图像处理程序。原因如下：
（1）C# 打开unsafe后，写的程序性能非常接近 C 程序的性能（当然，用不了SIMD是个缺陷。mono暂时不考虑。可通过挂接一个轻量级的C库来解决。）；
（2）写C#代码比写C代码爽多了快多了（命名空间、不用管头文件、快速编译、重构、生成API文档 ……）；
（3）庞大的.Net Framework是强有力的后盾。比如，客户想看演示，用Asp.Net写个页面，传个图片给后台，处理了显示出来。还有那些非性能攸关的地方，可以大量使用.Net Framework中的类，大幅度减少开发时间；
（4）结合强大的WPF，可以快速实现复杂的功能
（5）大量的时间在算法研究、实现和优化上，用C#可以把那些无关的惹人烦的事情给降到最小，所牺牲的只是一丁点儿性能。如果生产平台没有.net环境，将C#代码转换为C/C++代码也很快。
====
补充测试VC 9.0 版本

VC 实现与 C# 实现略有区别，C#版本RGB,Lab使用struct来表示，VC下直接用的三个Byte Channel来表示，然后以 redChannel, greenChannel, blueChannel 来代表不同的 Channel Offset。以 nChannel 代表 Channel 数量。VC下有Stride，C#下无Stride。查表实现也和C#版本有区别，直接使用的是静态的表。O2优化。
E: 非查表实现

void      
::ImageQualityDetector::ConvertToLab(Orc::ImageInfo &img)      
{      
    static unsigned short icvLabCubeRootTab[] = {      
        0,161,203……        };
    const float labXr_32f = 0.433953f /* = xyzXr_32f / 0.950456 */;      
    const float labXg_32f = 0.376219f /* = xyzXg_32f / 0.950456 */;      
    const float labXb_32f = 0.189828f /* = xyzXb_32f / 0.950456 */;
    const float labYr_32f = 0.212671f /* = xyzYr_32f */;      
    const float labYg_32f = 0.715160f /* = xyzYg_32f */;      
    const float labYb_32f = 0.072169f /* = xyzYb_32f */;
    const float labZr_32f = 0.017758f /* = xyzZr_32f / 1.088754 */;      
    const float labZg_32f = 0.109477f /* = xyzZg_32f / 1.088754 */;      
    const float labZb_32f = 0.872766f /* = xyzZb_32f / 1.088754 */;
    const float labRx_32f = 3.0799327f  /* = xyzRx_32f * 0.950456 */;      
    const float labRy_32f = (-1.53715f) /* = xyzRy_32f */;      
    const float labRz_32f = (-0.542782f)/* = xyzRz_32f * 1.088754 */;
    const float labGx_32f = (-0.921235f)/* = xyzGx_32f * 0.950456 */;      
    const float labGy_32f = 1.875991f   /* = xyzGy_32f */ ;      
    const float labGz_32f = 0.04524426f /* = xyzGz_32f * 1.088754 */;
    const float labBx_32f = 0.0528909755f /* = xyzBx_32f * 0.950456 */;      
    const float labBy_32f = (-0.204043f)  /* = xyzBy_32f */;      
    const float labBz_32f = 1.15115158f   /* = xyzBz_32f * 1.088754 */;
    const float labT_32f = 0.008856f;
    const int lab_shift = 10;
    const float labLScale2_32f = 903.3f;
    const int labXr = (int)((labXr_32f) * (1  4) > 4)) ;      
            line[0] = (byte)l;      
            line[1] = (byte)a;      
            line[2] = (byte)b;
            line += nChannel;      
        }      
    }      
}

F: 查表实现

void      
::ImageQualityDetector::FastConvertToLab(Orc::ImageInfo &img)      
{      
    static const byte Rgb2LabSmallTable[] = {      
    0,    129,    128 ……      
    };
    int width = img.Width;      
    int height = img.Height;      
    int nChannel = img.NChannel;      
    int redChannel = img.RedChannel;      
    int greenChannel = img.GreenChannel;      
    int blueChannel = img.BlueChannel;      
    for(int h = 0; h < height; h++)      
    {      
        byte *line = img.GetLine(h);      
        for(int w = 0; w < width; w++)      
        {      
            int red = line[redChannel];      
            int green = line[greenChannel];      
            int blue = line[blueChannel];      
            int index = 3 * (((red >> 4) > 4) > 4)) ;      
            line[0] = Rgb2LabSmallTable[index];      
            line[1] = Rgb2LabSmallTable[index + 1];      
            line[2] = Rgb2LabSmallTable[index + 2];      
            line += nChannel;      
        }      
    }      
}

测试结果：

图像2，大小：1845×611
A：25  23    23   23  
B：23  34    20   21  
C:  15   15   15   15 
D:  13   13   13   13      
E:  32   30   37   37      
F:  15    10   13  11
图像3，大小：3888×2592
A：209  210  211  210      
B：185  188  191  185      
C:  136  134  135  135      
D:  117  118  122  117      
E:  242  240  243  239      
F:  70    69    67    67

====
补充测试：C# 下查表实现（Byte数组）

G: C#下直接查找Byte数组，相关代码

static byte[] Rgb2LabSmallTable = new byte[] {     
    0,    129,    128, … }
private unsafe void ConvertToImageLab24Fast(ImageRgb24 img)     
{      
    Rgb24* rgbStart = img.Start;      
    Rgb24* rgbEnd = img.Start + img.Length;      
    while (rgbStart != rgbEnd)      
    {      
        Rgb24 rgb = *rgbStart;      
        int index = (((int)(rgb.Red) >> 4) > 4) > 4);      
        rgbStart->Red = Rgb2LabSmallTable[index];      
        rgbStart->Green = Rgb2LabSmallTable[index+1];      
        rgbStart->Blue = Rgb2LabSmallTable[index+2];      
        rgbStart++;      
    }      
}

测试结果：

图像2，大小：1845×611
A：25  23    23   23  
B：23  34    20   21  
C:  15   15   15   15 
D:  13   13   13   13      
E:  32   30   37   37      
F:  15    10   13  11      
G:  12    11   13  11
图像3，大小：3888×2592
A：209  210  211  210      
B：185  188  191  185      
C:  136  134  135  135      
D:  117  118  122  117      
E:  242  240  243  239      
F:  70    69    67    67      
G:  64    64    65    64

====
补充测试：同一种实现下的C#和VC性能对比，附下载

下面消除两种语言的测试区别，C#版本查表时使用指针而非数组，VC下使用无Stride的Rgb24，相关测试代码见 ​​下载链接​​ 。
这又形成了4个测试用例：
H- C#，非查表；I-C#，查表; J-C++，非查表; K-C++，查表
C# 版为 .Net 4.0, VS2010 ，代码中选择快速一项为测试I，不选择为测试H。
C++版 - VS2008。选择快速一项为测试K，不选择为测试J。
测试结果：

图像2，大小：1845×611
H: 31  29  36  32     
I:  10  10  10  10      
J:  39  33  33  30      
K:  9    8    8    8
图像3，大小：3888×2592
H: 195  194  194  195     
I:  53    52    51    52      
J: 220  218  218  222      
K: 41   42    41   41

结论：

C#下图像开发是很给力的！还在犹豫什么呢？

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4