大多数实时网络游戏，将 server 的时间和 client 的时间校对一致是可以带来许多其他系统设计上的便利的。这里说的对时，并非去调整 client 的 os 中的时钟，而是把 game client 内部的逻辑时间调整跟 server 一致即可。

一个粗略的对时方案可以是这样的，client 发一个数据包给 server，里面记录下发送时刻。server 收到后，立刻给这个数据包添加一个server 当前时刻信息，并发还给 client 。因为大部分情况下，game server 不会立刻处理这个包，所以，可以在处理时再加一个时刻。两者相减，client 可以算得包在 server 内部耽搁时间。

client 收到 server 发还的对时包时，因为他可以取出当初发送时自己附加的时刻信息，并知道当前时刻，也就可以算出这个数据包来回的行程时间。这里，我们假定数据包来回时间相同，那么把 server 通知的时间，加上行程时间的一半，则可以将 client 时间和 server 时间校对一致。

系列前面的两篇文章写的内容太简单了，本文对我理解的GDI+做一个综述，不再涉及代码细节。

GDI+中共有三种坐标，全局坐标、页面坐标和设备坐标。在GDI+的绘图调用中，传入的坐标位于全局坐标内，全局坐标经由全局变换转换到页面坐标，页面坐标再通过页面变换计算出设备坐标。

全局变换通过Graphics.Transform指定，其类型为Matrix。GDI+中的矩阵为3x3浮点矩阵，可以通过Matrix类的方法和属性来修改全局变换，也可以通过Graphics类上的TranslateTransform等方法来设定。页面变换通过Graphics类的PageUnit和PageScale来设定坐标单位和缩放倍数。

Point, Size, Rectangle是GDI+中常用的度量类型，并且都具有对应的float类型。Color则代表了32位A8R8G8B8的颜色。这一些都是基本的值类型，在实际使用的时候，要牢记其值类型的特征，类似o.Size.Width = 100的代码是没有作用的，因为.Width = 100是作用在了o.Size返回的临时变量上了，对于o的状态没有任何影响。

GraphicsPath，Region, Image则是GDI+中的一些资源性的类型，在使用完成后要尽快Dispose。GraphicsPath是一系列连续的线，包含直线和曲线。Region则表示封闭的一个区域，这个区域的边界可以由GraphicsPath来描述。Image表示一个图形，其中表现像素组成的位图的派生类为Bitmap，表现失量绘图指令组成的图形的派生类为Metafile。计算机屏幕最擅长展现两维的数据，因此Rectangle视为最简单的一种Region，并且应用面也非常广泛，计算包含整个Region的Rectangle也是非常常见的一种操作。

Brush用来填充一个Region，填充时可以使用单色填充，可以使用纹理（图片）填充，也可以使用线型填充和渐变填充，.NET中封充的GDI+提供了SolidBrush，TextureBrush，HatchBrush，LinearGradientBrush和PathGradientBrush类。Brush也是需要及时Dispose的，对于SolidBrush，可使用SystemBrushes和Brushes中的静态属性，获取预定义的Brush对表，免去Dispose的麻烦。

Pen是用来画线的，GDI+的线是有宽度的，也就有其内部区域，因此GDI+中的Pen需要一个Brush实例来构造。同样SystemPens和Pens中提供了预定义的单色Pen实例。

此外Font对象用来实现GDI+中不同字体的输出，Graphics类提供了一个MeasureString方法计算一段字符串绘制出来时占据的区域大小。

Graphics类提供了一系列Draw...方法，使用特定的Pen来绘制一定的形状，Fill...系列则使用特定的Brush来填充指定区域。

Graphics的Clip属性通过一个Region类的实例指定GDI+有效绘制区域，这是一个基础信息，Graphics的属性ClipBounds，IsClipEmpty，IsVisibleClipEmpty，VisibleClipBounds均基于Clip属性，并且为只读的。

CompositingQuality，InterpolationMode，PixelOffsetMode，SmoothingMode，TextRenderingHint用来控制绘制输出质量，质量越高，速度越慢。CompositingMode用来启用Alpha Blend，TextContrast控制文本输出时的Gamma值，RenderingOrigin用来控制8bit/16bit色深时的色彩拌动和Hatch Brush的起始点。

这些内容对之后的Minesweeper内容足够了，如果有问题，欢迎在评论中提出。

       1. BMP文件组成

　　BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。文件头主要包含文件的大小、文件类型、图像数据偏离文件头的长度等信息；位图信息头包含图象的尺寸信息、图像用几个比特数值来表示一个像素、图像是否压缩、图像所用的颜色数等信息。颜色信息包含图像所用到的颜色表，显示图像时需用到这个颜色表来生成调色板，但如果图像为真彩色，既图像的每个像素用24个比特来表示，文件中就没有这一块信息，也就不需要操作调色板。文件中的数据块表示图像的相应的像素值，需要注意的是：图像的像素值在文件中的存放顺序为从左到右，从下到上，也就是说，在BMP文件中首先存放的是图像的最后一行像素，最后才存储图像的第一行像素，但对与同一行的像素，则是按照先左边后右边的的顺序存储的；另外一个需要读者朋友关注的细节是：文件存储图像的每一行像素值时，如果存储该行像素值所占的字节数为4的倍数，则正常存储，否则，需要在后端补0，凑足4的倍数。

　　2. BMP文件头

　　BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。其结构定义如下:

　　注意：RGBQUAD数据结构中，增加了一个保留字段rgbReserved，它不代表任何颜色，必须取固定的值为“0”，同时，RGBQUAD结构中定义的颜色值中，红色、绿色和蓝色的排列顺序与一般真彩色图像文件的颜色数据排列顺序恰好相反，既：若某个位图中的一个像素点的颜色的描述为“00，00，ff，00”，则表示该点为红色，而不是蓝色。

　　5. 位图数据

　　位图数据记录了位图的每一个像素值或该对应像素的颜色表的索引值，图像记录顺序是在扫描行内是从左到右,扫描行之间是从下到上。这种格式我们又称为Bottom_Up位图，当然与之相对的还有Up_Down形式的位图，它的记录顺序是从上到下的，对于这种形式的位图，也不存在压缩形式。位图的一个像素值所占的字节数：当biBitCount=1时，8个像素占1个字节；当biBitCount=4时，2个像素占1个字节；当biBitCount=8时，1个像素占1个字节；当biBitCount=24时,1个像素占3个字节，此时图像为真彩色图像。当图像不是为真彩色时，图像文件中包含颜色表，位图的数据表示对应像素点在颜色表中相应的索引值，当为真彩色时，每一个像素用三个字节表示图像相应像素点彩色值，每个字节分别对应R、G、B分量的值，这时候图像文件中没有颜色表。上面我已经讲过了，Windows规定图像文件中一个扫描行所占的字节数必须是4的倍数(即以字为单位),不足的以0填充，图像文件中一个扫描行所占的字节数计算方法：

　　位图数据的大小按下式计算(不压缩情况下)：

　　DataSize= DataSizePerLine* biHeight。

　　上述是BMP文件格式的说明，搞清楚了以上的结构，就可以正确的操作图像文件，对它进行读或写操作了。

　　计算机彩色显示器显示色彩的原理与彩色电视机一样，都是采用R（Red）、G（Green）、B（Blue）相加混色的原理：通过发射出三种不同强度的电子束，使屏幕内侧覆盖的红、绿、蓝磷光材料发光而产生色彩。这种色彩的表示方法称为RGB色彩空间表示（它也是多媒体计算机技术中用得最多的一种色彩空间表示方法）。
　　根据三基色原理，任意一种色光F都可以用不同分量的R、G、B三色相加混合而成。
F = r [ R ] + g [ G ] + b [ B ]
　　其中，r、g、b分别为三基色参与混合的系数。当三基色分量都为0（最弱）时混合为黑色光；而当三基色分量都为k（最强）时混合为白色光。调整r、g、b三个系数的值，可以混合出介于黑色光和白色光之间的各种各样的色光。
那么YUV又从何而来呢？在现代彩色电视系统中，通常采用三管彩色摄像机或彩色CCD摄像机进行摄像，然后把摄得的彩色图像信号经分色、分别放大校正后得到RGB，再经过矩阵变换电路得到亮度信号Y和两个色差信号R－Y（即U）、B－Y（即V），最后发送端将亮度和色差三个信号分别进行编码，用同一信道发送出去。这种色彩的表示方法就是所谓的YUV色彩空间表示。
采用YUV色彩空间的重要性是它的亮度信号Y和色度信号U、V是分离的。如果只有Y信号分量而没有U、V分量，那么这样表示的图像就是黑白灰度图像。彩色电视采用YUV空间正是为了用亮度信号Y解决彩色电视机与黑白电视机的兼容问题，使黑白电视机也能接收彩色电视信号。
　　YUV与RGB相互转换的公式如下（RGB取值范围均为0-255）：

Y = 0.299R + 0.587G + 0.114B
U = -0.147R - 0.289G + 0.436B
V = 0.615R - 0.515G - 0.100B

R = Y + 1.14V
G = Y - 0.39U - 0.58V
B = Y + 2.03U

　　在DirectShow中，常见的RGB格式有RGB1、RGB4、RGB8、RGB565、RGB555、RGB24、RGB32、ARGB32等；常见的YUV格式有YUY2、YUYV、YVYU、UYVY、AYUV、Y41P、Y411、Y211、IF09、IYUV、YV12、YVU9、YUV411、YUV420等。作为视频媒体类型的辅助说明类型（Subtype），它们对应的GUID见表2.3。

　　表2.3 常见的RGB和YUV格式

GUID    格式描述
MEDIASUBTYPE_RGB1    2色，每个像素用1位表示，需要调色板
MEDIASUBTYPE_RGB4    16色，每个像素用4位表示，需要调色板
MEDIASUBTYPE_RGB8    256色，每个像素用8位表示，需要调色板
MEDIASUBTYPE_RGB565    每个像素用16位表示，RGB分量分别使用5位、6位、5位
MEDIASUBTYPE_RGB555    每个像素用16位表示，RGB分量都使用5位（剩下的1位不用）
MEDIASUBTYPE_RGB24    每个像素用24位表示，RGB分量各使用8位
MEDIASUBTYPE_RGB32    每个像素用32位表示，RGB分量各使用8位（剩下的8位不用）
MEDIASUBTYPE_ARGB32    每个像素用32位表示，RGB分量各使用8位（剩下的8位用于表示Alpha通道值）
MEDIASUBTYPE_YUY2    YUY2格式，以4:2:2方式打包
MEDIASUBTYPE_YUYV    YUYV格式（实际格式与YUY2相同）
MEDIASUBTYPE_YVYU    YVYU格式，以4:2:2方式打包
MEDIASUBTYPE_UYVY    UYVY格式，以4:2:2方式打包
MEDIASUBTYPE_AYUV    带Alpha通道的4:4:4 YUV格式
MEDIASUBTYPE_Y41P    Y41P格式，以4:1:1方式打包
MEDIASUBTYPE_Y411    Y411格式（实际格式与Y41P相同）
MEDIASUBTYPE_Y211    Y211格式
MEDIASUBTYPE_IF09    IF09格式
MEDIASUBTYPE_IYUV    IYUV格式
MEDIASUBTYPE_YV12    YV12格式
MEDIASUBTYPE_YVU9    YVU9格式

　　下面分别介绍各种RGB格式。

　　RGB1、RGB4、RGB8都是调色板类型的RGB格式，在描述这些媒体类型的格式细节时，通常会在BITMAPINFOHEADER数据结构后面跟着一个调色板（定义一系列颜色）。它们的图像数据并不是真正的颜色值，而是当前像素颜色值在调色板中的索引。以RGB1（2色位图）为例，比如它的调色板中定义的两种颜色值依次为0x000000（黑色）和0xFFFFFF（白色），那么图像数据001101010111…（每个像素用1位表示）表示对应各像素的颜色为：黑黑白白黑白黑白黑白白白…。

　　RGB565使用16位表示一个像素，这16位中的5位用于R，6位用于G，5位用于B。程序中通常使用一个字（WORD，一个字等于两个字节）来操作一个像素。当读出一个像素后，这个字的各个位意义如下：
     高字节              低字节
R R R R R G G G     G G G B B B B B
可以组合使用屏蔽字和移位操作来得到RGB各分量的值：

#define RGB565_MASK_RED    0xF800
#define RGB565_MASK_GREEN  0x07E0
#define RGB565_MASK_BLUE   0x001F
R = (wPixel & RGB565_MASK_RED) >> 11;   // 取值范围0-31
G = (wPixel & RGB565_MASK_GREEN) >> 5;  // 取值范围0-63
B =  wPixel & RGB565_MASK_BLUE;         // 取值范围0-31

　　RGB555是另一种16位的RGB格式，RGB分量都用5位表示（剩下的1位不用）。使用一个字读出一个像素后，这个字的各个位意义如下：
     高字节             低字节
X R R R R G G       G G G B B B B B       （X表示不用，可以忽略）
可以组合使用屏蔽字和移位操作来得到RGB各分量的值：

#define RGB555_MASK_RED    0x7C00
#define RGB555_MASK_GREEN  0x03E0
#define RGB555_MASK_BLUE   0x001F
R = (wPixel & RGB555_MASK_RED) >> 10;   // 取值范围0-31
G = (wPixel & RGB555_MASK_GREEN) >> 5;  // 取值范围0-31
B =  wPixel & RGB555_MASK_BLUE;         // 取值范围0-31

　　RGB24使用24位来表示一个像素，RGB分量都用8位表示，取值范围为0-255。注意在内存中RGB各分量的排列顺序为：BGR BGR BGR…。通常可以使用RGBTRIPLE数据结构来操作一个像素，它的定义为：

typedef struct tagRGBTRIPLE {
  BYTE rgbtBlue;    // 蓝色分量
  BYTE rgbtGreen;   // 绿色分量
  BYTE rgbtRed;     // 红色分量
} RGBTRIPLE;

　　RGB32使用32位来表示一个像素，RGB分量各用去8位，剩下的8位用作Alpha通道或者不用。（ARGB32就是带Alpha通道的RGB32。）注意在内存中RGB各分量的排列顺序为：BGRA BGRA BGRA…。通常可以使用RGBQUAD数据结构来操作一个像素，它的定义为：

typedef struct tagRGBQUAD {
  BYTE    rgbBlue;      // 蓝色分量
  BYTE    rgbGreen;     // 绿色分量
  BYTE    rgbRed;       // 红色分量
  BYTE    rgbReserved;  // 保留字节（用作Alpha通道或忽略）
} RGBQUAD;

　　　下面介绍各种YUV格式。YUV格式通常有两大类：打包（packed）格式和平面（planar）格式。前者将YUV分量存放在同一个数组中，通常是几个相邻的像素组成一个宏像素（macro-pixel）；而后者使用三个数组分开存放YUV三个分量，就像是一个三维平面一样。表2.3中的YUY2到Y211都是打包格式，而IF09到YVU9都是平面格式。（注意：在介绍各种具体格式时，YUV各分量都会带有下标，如Y0、U0、V0表示第一个像素的YUV分量，Y1、U1、V1表示第二个像素的YUV分量，以此类推。）

　　　YUY2（和YUYV）格式为每个像素保留Y分量，而UV分量在水平方向上每两个像素采样一次。一个宏像素为4个字节，实际表示2个像素。（4:2:2的意思为一个宏像素中有4个Y分量、2个U分量和2个V分量。）图像数据中YUV分量排列顺序如下：
Y0 U0 Y1 V0    Y2 U2 Y3 V2 …

　　YVYU格式跟YUY2类似，只是图像数据中YUV分量的排列顺序有所不同：
Y0 V0 Y1 U0    Y2 V2 Y3 U2 …

　　UYVY格式跟YUY2类似，只是图像数据中YUV分量的排列顺序有所不同：
U0 Y0 V0 Y1    U2 Y2 V2 Y3 …

　　AYUV格式带有一个Alpha通道，并且为每个像素都提取YUV分量，图像数据格式如下：
A0 Y0 U0 V0    A1 Y1 U1 V1 …

　　Y41P（和Y411）格式为每个像素保留Y分量，而UV分量在水平方向上每4个像素采样一次。一个宏像素为12个字节，实际表示8个像素。图像数据中YUV分量排列顺序如下：
U0 Y0 V0 Y1    U4 Y2 V4 Y3    Y4 Y5 Y6 Y8 …

　　Y211格式在水平方向上Y分量每2个像素采样一次，而UV分量每4个像素采样一次。一个宏像素为4个字节，实际表示4个像素。图像数据中YUV分量排列顺序如下：
Y0 U0 Y2 V0    Y4 U4 Y6 V4 …

　　YVU9格式为每个像素都提取Y分量，而在UV分量的提取时，首先将图像分成若干个4 x 4的宏块，然后每个宏块提取一个U分量和一个V分量。图像数据存储时，首先是整幅图像的Y分量数组，然后就跟着U分量数组，以及V分量数组。IF09格式与YVU9类似。

　　IYUV格式为每个像素都提取Y分量，而在UV分量的提取时，首先将图像分成若干个2 x 2的宏块，然后每个宏块提取一个U分量和一个V分量。YV12格式与IYUV类似。

　　YUV411、YUV420格式多见于DV数据中，前者用于NTSC制，后者用于PAL制。YUV411为每个像素都提取Y分量，而UV分量在水平方向上每4个像素采样一次。YUV420并非V分量采样为0，而是跟YUV411相比，在水平方向上提高一倍色差采样频率，在垂直方向上以U/V间隔的方式减小一半色差采样。

调用模型

利用面向对象思想多态性,调用方保存着被调用方的基础接口指针(一般称呼为 钩子),调用方直接调用接口指针里面方法,方法具体实现逻辑由

该接口的派生类实现.示意图:

基于事件驱动的数据处理模型

为系统功能设计，需要处理网络事件数据SocketEvent，数据库事件数据DatabaseEvent，定时器事件数据TimerEvent等，为此建立数据队列服

务QueueService,为每一队列建立多个子线程QueueServiceThread处理。数据队列服务提供添加事件数据方法AddToQueue，设置数据队列服务钩

子SetQueueServiceSink，让数据队列服务钩子QueueServiceSink做具体逻辑事件数据处理。
示意图:

再者，根据网络,数据库等特定功能，构建网络，数据库等管理服务，实现数据队列服务钩子QueueServiceSink方法，调度事件数据执行外部处

理接口，外部处理接口具体由二次开发用户实现。示意图:

事件数据设计

框架体系设计

功能模块划分

数据队列服务QueueService模块设计

    基本设计概念

    建立一个内存链表，保存事件数据，对外部提供方法往链表添加事件数据并通知线程，同时启动多个处理线程，从数据链表里获取事件数据，执行外部钩子方法进行处理.线程事件通知采用完成端口技术.

   类与接口设计

     接口设计

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/dotnet90/archive/2009/05/05/4152401.aspx

世界变换就是将物体顶点坐标从模型空间转换到世界空间。在模型空间里，顶点位置坐标依据模型的本地坐标系的原点而定，在世界空间里，所有模型的顶点共用一个原点，即世界坐标系原点。事实上，世界变换就是将一个模型从本地空间重新定位到世界空间内。从模型空间到世界空间的转换实际上就是对模型进行平移、旋转、缩放以及它们的任意组合变换。

使用三维模型制作软件，例如3dmax，制作三维模型时，首先需要为模型设定一个坐标系，模型上的顶点坐标就是设定的模型自身坐标系下的坐标，这个坐标系也就是上面提到的本地坐标系或模型空间。

1、世界变换矩阵

在处理三维图像的应用程序中，可使用世界变换完成一个物体（确切的说是一个坐标或一系列坐标）的平移、旋转和缩放。当然也可以完成这三种变换的任意组合。具体的方法就是通过下式：

将任意一点P(x, y, z)转换到p'(x', y', z')，上式也可以表示为以下形式：

p'(x', y', z') = P(x, y, z) . M_world

M_world就是世界变换矩阵。也就是它实现了物体的平移、旋转、缩放和它们的复合变换。在定义好世界变换矩阵后，调用函数IDirect3DDevice9::SetTransform()并指定第一个参数为D3DTS_WORLD，第二个参数为相应的世界变换矩阵即可。

2、平移

可以通过下式（也就是下面的平移变换矩阵）：

将点（x, y, z）沿x、y和z轴分别移动T_x、T_y、T_z，到另一点（x'，y'，z'）。很显然，只要得到了这个平移矩阵，平移工作就可以完成。

为方便起见，D3DX扩展函数库d3dx9.lib提供了函数D3DXMatrixTranslation()，用它可以很方便地生成一个平移世界矩阵。该函数的声明如下:

Builds a matrix using the specified offsets.

D3DXMATRIX * D3DXMatrixTranslation(
  D3DXMATRIX * pOut,
  FLOAT x,
  FLOAT y,
  FLOAT z
);

Parameters

pOut

[in, out] Pointer to the D3DXMATRIX structure that is the result of the operation.

x

[in] X-coordinate offset.

y

[in] Y-coordinate offset.

z

[in] Z-coordinate offset.

Return Values

Pointer to a D3DXMATRIX structure that contains a translated transformation matrix.

Remarks

The return value for this function is the same value returned in the pOut parameter. In this way, the D3DXMATRIXTranslation can be used as a parameter for another function.

3、旋转

与平移类似，使用下面的四阶矩阵可以将点（x, y, z）绕x轴旋转θ角，到新点（x', y', z'）:

绕y轴旋转θ角时的矩阵为：

绕z轴旋转θ角时的矩阵为：

θ指旋转角度，单位是弧度，具体是指沿着旋转轴的指向（即正方向）向坐标原点看去顺指针旋转过的角度。

同样可以使用D3DX扩展函数库d3dx9.lib提供的函数D3DXMatrixRotationX()、D3DXMatrixRotationY()和D3DXMatrixRotationZ()方便地创建旋转矩阵，这三个函数的声明如下，因声明类似，只列出D3DXMatrixRotationX()的使用说明:

Builds a matrix that rotates around the x-axis.

D3DXMATRIX * D3DXMatrixRotationX(
  D3DXMATRIX * pOut,
  FLOAT Angle
);

Parameters

pOut

[in, out] Pointer to the D3DXMATRIX structure that is the result of the operation.

Angle

[in] Angle of rotation in radians. Angles are measured clockwise when looking along the rotation axis toward the origin.

Return Values

Pointer to a D3DXMATRIX structure rotated around the x-axis.

Remarks

The return value for this function is the same value returned in the pOut parameter. In this way, the D3DXMatrixRotationX function can be used as a parameter for another function.

4、缩放

使用下面的四阶矩阵可以将点（x, y, z）在x、y、z轴上各缩放Sx、Sy、Sz，到另一点（x', y', z'）。

同样，可以使用Direct3D扩展实用库中的函数D3DXMatrixScaling()来生成缩放矩阵，该函数的声明如下：

Builds a matrix that scales along the x-axis, the y-axis, and the z-axis.

D3DXMATRIX * D3DXMatrixScaling(
  D3DXMATRIX * pOut,
  FLOAT sx,
  FLOAT sy,
  FLOAT sz
);

Parameters

pOut

[in, out] Pointer to the D3DXMATRIX structure that is the result of the operation.

sx

[in] Scaling factor that is applied along the x-axis.

sy

[in] Scaling factor that is applied along the y-axis.

sz

[in] Scaling factor that is applied along the z-axis.

Return Values

Pointer to the scaling transformation D3DXMATRIX.

Remarks

The return value for this function is the same value returned in the pOut parameter. In this way, the D3DXMatrixScaling function can be used as a parameter for another function.

5、矩阵连接与复合变换

在大多数情况下，Direct3D中的物体需要进行的世界变换不止一个，而往往是多个世界变换的组合，这时可以使用矩阵连接来实现这种复合变换。因为矩阵的一个优点是通过矩阵的相乘，将两个或更多矩阵的作用合并在一起实现。为了先后实现一个模型的旋转和移动，不需要使用两个矩阵，可以将旋转矩阵和平移矩阵相乘得到一个复合矩阵以实现所有功能。这个过程叫做矩阵连接（matrix concatention），可以用下面的公式表示：

C = M₁ * M₂ * ... * M_n-1 * M_n

在这个公式里，C是实现复合变换的复合矩阵，从M₁到M_n是只能实现某一种世界变换的单独矩阵（individual matrices）。大多数情况下是两到三个矩阵连接，但这个数量没有限制。

使用函数D3DXMatrixMultiply() 可完成矩阵的乘法，该函数的说明如下：

Determines the product of two matrices.

D3DXMATRIX * D3DXMatrixMultiply(
  D3DXMATRIX * pOut,
  CONST D3DXMATRIX * pM1,
  CONST D3DXMATRIX * pM2
);

Parameters

pOut

[in, out] Pointer to the D3DXMATRIX structure that is the result of the operation.

pM1

[in] Pointer to a source D3DXMATRIX structure.

pM2

[in] Pointer to a source D3DXMATRIX structure.

Return Values

Pointer to a D3DXMATRIX structure that is the product of two matrices.

Remarks

The result represents the transformation M1 followed by the transformation M2 (Out = M1 * M2).

The return value for this function is the same value returned in the pOut parameter. In this way, the D3DXMatrixMultiply function can be used as a parameter for another function.

矩阵pOut表示最终的复合变换，也就是先进行矩阵pM1表示的变换，然后又进行矩阵pM2表示的变换。

在矩阵的乘法中，顺序是很关键的。无论要创建什么样的世界变换矩阵，记住从左到右的原则才能确保实现想要的效果，也就是说，一个复合矩阵的视觉效果是按从左到右的顺序各单独矩阵视觉效果的组合。假设一个物体先绕y轴旋转，然后把它移动到场景内的另一个位置。为实现这个效果，首先创建一个旋转矩阵R_y，然后乘以一个平移矩阵T_w：

W = R_y * T_w

在这个公式里，R_y表示绕y轴的旋转矩阵，T_w实现世界坐标系内的一次平移。矩阵的乘法不满足交换律。如果将这两个矩阵以相反的顺序相乘，效果是先平移，然后旋转。

逆反处理的算法如下：
设r，g，b分别为源图像像素f（i，j）的红，绿，蓝分量值，rr，gg，bb分别为处理后像素g（i，j）的红，绿，蓝分量值。则
rr=255-r
gg=255-g
bb=255-b

２.图像的平滑处理

算法如下：
平滑处理是指将源图像的每一个像素的颜色值由其相邻n*n个像素的平均值来代替。
例如，对于3*3点阵而言，设原图像某像素的值为f（i，j），平滑处理后该像素的值为g（i，j），则：
g(i,j)=(f(i,j)+f(i-1,j)+f(i+1,j)+f(i-1,j-1)+f(i,j-1)+f(i+1,j-1)+
f(i-1,j+1)+f(i,j+1)+f(i+1,j+1))/9
注意：该算法不能平滑图像边界的像素。

３. 图象的霓虹处理

算法：
对于3*3点阵，首先计算原图象像素f(i,j)的红，绿，蓝分量与相同行f（i+1，j）及同列f(i,j+1)相邻象素的梯度，即差的平方之和的平方根，然后将梯度值作为处理后的象素g(i,j)的红，绿，蓝分量值。
设r1,g1,b1分别为原图象象素f(i,j)的红，绿，蓝分量值，r2,g2,b2分别为相同行相邻象素f(i+1,j)的红，绿，蓝分量值，r3,g3,b3分别为同列相邻象素f(i,j+1)的红，绿，蓝分量值，rr,gg,bb为处理后象素g(i,j)的红，绿，蓝分量值，则：
rr1=(r1-r2)^2  rr2=(r1-r3)^2
gg1=(g1-g2)^2  gg2=(g1-g3)^2
bb1=(b1-b2)^2  bb2(b1-b3)^2
rr=2*(rr1+rr2)^0.5
gg=2*(gg1+gg2)^0.5
bb=2*(bb1+bb2)^0.5

４.图象的锐化处理

锐化处理的算法：
计算原图像像素f(i,j)的像素值与该像素与相邻像素f(i-1,j-1)像素值之差的绝对值得百分比之和，作为处理后图像像素g(i,j)的像素值。例如，设r1,g1,b1分别为f(i,j)的红、绿、蓝分量值，r2,g2,b2分别为f(i-1,j-1)的红、绿、蓝分量值，rr,gg,bb分别为g(i,j)的红、绿、蓝分量值，则：
rr=r1+0.25*abs(r1-r2)
gg=g1+0.25*abs(g1-g2)
bb=b1+0.25*abs(b1-b2)

５. 图像的浮雕处理

算法：
位图图像的浮雕处理的算法是：
g(i,j)=f(i,j)-f(i-1,j)+常数
式中，g(i,j)为处理后图像的像素值，f(i,j)为原图像的像素值，f(i-1,j)为前一个相邻像素的值。常数一般取128，即
rr=r1-r2+128
gg=g1-g2+128
bb=b1-b2+128
式中，r1,g1,b1分别为原图像的像素f(i,j)的红、绿、蓝分量值；r2,g2,b2分别为前一个相邻像素f(i-1,j)的红、绿、蓝分量值，rr,gg,bb,分别为处理后图像的像素g(i,j)的红、绿、蓝分量值.

６.图像的镶嵌处理

镶嵌处理算法如下：
镶嵌处理后的图像每一小矩阵内的所有像素值都取此矩阵内原图像各像素值之和的平均值。例如，对于3*3的子域：
g(i,j)=(f(i,j)+f(i-1,j)+f(i+1,j)+f(i-1,j-1)+f(i+1,j-1)+f(i-1,j+1)+f(i,j+1)+f(i+1,j+1))/9
则取：
g(i-1,j)=g(i,j)
g(i+1,j)=g(i,j)
g（i,j-1）=g(i,j)
g(i,j+1)=g(i,j)
g(i,j+1)=g(i,j)
g(i-1,j-1)=g(i,j)
g(i-1,j+1)=g(i,j)
g(i+1,j-1)=g(i,j)
g(i+1,j+1)=g(i,j)

７.图像的灰度处理

彩色图像灰度处理的算法如下：
c=tuxing.GetPixel(i,j)
r=c.R
g=c.G
b=c.B
rr=g(r 64)*64
gg=(g 64)*64
bb=(b 64)*64

８.图像缩小处理

以坐标原点为中心，将图像个像素坐标的X分量和Y分量分别乘以Sx，Sy，则可使图像进行整体放大和缩小。这时，
X'=X*Sx
Y'=Y*Sy
当Sx=Sy时，作相似变换;
当Sx!=Sy时，产生变形。

９.图像的平移处理

图像的平移变换是将图形上的点（x,y)在x方向（水平方向）和y方向（垂直方向）
分别移动dx和dy,则变换后点(x',y')坐标值为：
x'=x+dx
y'=y+dy

１０.图像的旋转变换

二维图像的旋转变换是以原点为中心，将点（x,y）旋转a角度而得到新的坐标（x',y'）的变换称为旋转变换。其数学表达式为：
x'=x*cosa-y*sina
y'=x*sina+y*cosa

１１.二维图像的对称变换

二维图像对称变换有以下几种情况.
1.以x轴为对称得对称变换。
以x轴为对称得点(x,y)的对称点(x',y')坐标为：
x'=x
y'=-y
2.以y轴为对称得对称变换。
以y轴为对称的点（x,y）的对称点(x',y')坐标为：
x'=-x
y'=y
3.以原点为对称的对称变换。
以原点为对称得点（x,y）的对称点（x',y'）坐标为：
x'=-x
y'=-y
对图像的每一个像素依据二维图形几何变换公式进行计算后，在进行图像显示，则可得到图像的几何变换。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/alin0725/archive/2007/03/28/1543860.aspx

    因问得人多了，有时我也思索和研究一下，总算找了个方法可以实现，虽然同专业的图像软件（如PhotoShop）文字描边效果相比差强人意，但可以凑合凑合，作为研究心得，将代码贴在这里备查。

    在《GDI+ 在Delphi程序的应用 -- 可调节的文字阴影特效》一文的内容的基础上，对文字阴影效果代码进行了改进和扩充，扩充的功能有2点：一是由原来只能产生黑色阴影扩充为任意颜色阴影；二是可以对阴影进行扩展。有了这2个功能，利用阴影效果也就可以进行文字描边了，推而广之，也可实现图像的描边。下面是具体的代码内容：

// 备份图像。Data: GDI+位图数据，32位ARGB格式; Dest: 备份目标; Color: 阴影颜色

procedure BackImage(Data: TBitmapData; Dest: Pointer; Color: TARGB);
asm
    push    esi
    push    edi

    mov     esi, [eax + 16]   // esi = Data.Scan0
    mov     edi, edx          // esi = Dest
    mov     edx, ecx          // edx = Color & 0xffffff
    and     edx, 0FFFFFFh
    mov     ecx, [eax]        // ecx = Data.Height * Data.Width
    imul    ecx, [eax + 4]
    cld

  @Loop:                       // for (; ecx >= 0; ecx --)
    or      [esi], edx
    movsd                      //   *edi++ = *esi++ & 0xff000000 | edx
    loop    @Loop

    pop     edi
    pop     esi
end;

// 扩展。Data: GDI+位图数据，32位ARGB格式; Source: 复制的源
// ExpMatrix: 卷积矩阵; MatrixSize：矩阵大小
procedure MakeExpand(Data: TBitmapData; Source, ExpMatrix: Pointer;
    MatrixSize: LongWord);
var
  Radius, mSize, rSize: LongWord;
  x, y: LongWord;
  Width, Height: Integer;
  Matrix: Pointer;
  Stride: LongWord;
asm
    push    esi
    push    edi
    push    ebx

    mov     esi, edx          // esi = Source
    mov     edi, [eax + 16]   // edi = Data.Scan0 + 3 (Alpha byte)
    add     edi, 3
    add     ecx, 3
    mov     Matrix, ecx       // Matrix = ExpMatrix + 3 (Alpha byte)
    mov     ecx, MatrixSize
    mov     edx, ecx
    dec     ecx
    mov     ebx, [eax]
    sub     ebx, ecx
    mov     Width, ebx        // Width = Data.Width - (MatrixSize - 1)
    mov     ebx, [eax + 4]
    sub     ebx, ecx
    mov     Height, ebx       // Height = Data.Height - (MatrixSize - 1)
    shr     ecx, 1
    mov     Radius, ecx       // Radius = MatrixSize / 2
    mov     eax, [eax + 8]
    mov     Stride, eax
    mov     mSize, eax
    shl     edx, 2
    sub     mSize, edx        // mSize = Data.Stride - MatrixSize * 4
    add     eax, 4
    imul    eax, ecx
    add     eax, 3
    add     esi, eax          // esi = esi + (Data.Stride * Radius + Radius * 4 + 3)
    shl     ecx, 3
    mov     rSize, ecx        // rSize = Radius * 2 * 4

    mov     y, 0              // for (y = 0; y < Height; y ++)
  @yLoop:                     // {
    mov     x, 0              //   for (x = 0; x < Width; x ++)
  @xLoop:                     //   {
    test    [esi], 0ffh       //     if (*esi != 0)
    jz      @NextPixel        //     {
    test    [esi - 4], 0ffh
    jz      @001
    test    [esi + 4], 0ffh
    jz      @001
    mov     ebx, Stride
    test    [esi + ebx], 0ffh
    jz      @001
    neg     ebx
    test    [esi + ebx], 0ffh
    jnz     @NextPixel
  @001:
    push    edi               //       Save(edi)
    mov     ebx, Matrix       //       ebx = Matrix
    mov     edx, MatrixSize   //       for (I = 0; I < MatrixSize; I ++)
  @Loop3:                     //       {
    mov     ecx, MatrixSize   //         for (J = 0; J <= MatrixSize; J ++)
  @Loop4:                     //         {
    mov      al, [ebx]        //           *edi = max(*ebx, *edi)
    cmp     al, [edi]
    jb      @002
    mov     [edi], al
  @002:
    add     edi, 4            //           edi += 4
    add     ebx, 4            //           ebx += 4
    loop    @Loop4            //         }
    add     edi, mSize        //         edi += mSize
    dec     edx
    jnz     @Loop3            //       }
    pop     edi               //       Reset(edi)
  @NextPixel:                 //     }
    add     edi, 4            //     edi += 4
    add     esi, 4            //     esi += 4
    inc     x
    mov     eax, x
    cmp     eax, Width
    jl      @xLoop            //   }
    add     esi, rSize
    add     edi, rSize
    inc     y
    mov     eax, y
    cmp     eax, Height
    jl      @yLoop            // }

    pop     ebx
    pop     edi
    pop     esi
end;

procedure GdipShadow(Data: TBitmapData; Buf: Pointer; Radius: LongWord);
var
  Gauss: array of Integer;
  Q: Double;
  x, y, n, z: Integer;
  p: PInteger;
begin
  // 根据半径计算高斯模糊矩阵
  Q := Radius / 2;
  if Q = 0 then Q := 0.1;
  n := Radius shl 1 + 1;
  SetLength(Gauss, n * n);
  p := @Gauss[0];
  z := 0;
  for x := -Radius to Radius do
    for y := -Radius to Radius do
    begin
      p^ := Round(Exp(-(x * x + y * y) / (2.0 * Q * Q)) / (2.0 * PI * Q * Q) * 1000.0);
      Inc(z, p^);
      Inc(p);
    end;
  MakeShadow(Data, Buf, Gauss, n, z);
end;

procedure GdipBorder(Data: TBitmapData; Buf: Pointer; Expand: LongWord; Color: TARGB);
var
  bmp: TGpBitmap;
  bg: TGpGraphics;
  Data1: TBitmapData;
  Size: Integer;
begin
  Size := Expand shl 1 + 1;
  bmp := TGpBitmap.Create(Size, Size, pf32bppARGB);
  bg := TGpGraphics.Create(bmp);
  try
    // 制造一个直径=Size，消除锯齿后的圆作为描边（或扩展）的位图画笔
    bg.SmoothingMode := smAntiAlias;
    bg.PixelOffsetMode := pmHalf;
    bg.FillEllipse(Brushs[Color], 0, 0, Size, Size);
    Data1 := bmp.LockBits(GpRect(0, 0, Size, Size), [imRead], pf32bppARGB);
    try
      // 用位图画笔扩展图像
      MakeExpand(Data, Buf, Data1.Scan0, Size);
    finally
      bmp.UnlockBits(Data1);
    end;
  finally
    bg.Free;
    bmp.Free;
  end;
end;

procedure DrawShadow(const g: TGpGraphics; const Bitmap: TGpBitmap;
    const layoutRect: TGpRectF; ShadowSize, Distance: LongWord;
    Angle: Single; Color: TARGB; Expand: LongWord);
var
  dr, sr: TGpRectF;
  Data: TBitmapData;
  Buf: Pointer;
  SaveScan0: Pointer;
begin
  Data := Bitmap.LockBits(GpRect(0, 0, Bitmap.Width, Bitmap.Height),
                          [imRead, imWrite], pf32bppARGB);
  GetMem(Buf, Data.Height * Data.Stride);
  try
    BackImage(Data, Buf, Color);
    if Expand > ShadowSize then
      Expand := ShadowSize;
    if Expand <> 0 then            // 处理文字阴影扩展
      if Expand <> ShadowSize then
      begin
        SaveScan0 := Data.Scan0;
        Data.Scan0 := Buf;
        GdipBorder(Data, SaveScan0, Expand, Color);
        Data.Scan0 := SaveScan0;
      end else
        GdipBorder(Data, Buf, Expand, Color);
    if Expand <> ShadowSize then   // 处理文字阴影效果
      GdipShadow(Data, Buf, ShadowSize - Expand);
  finally
    FreeMem(Buf);
    Bitmap.UnlockBits(Data);
  end;
  sr := GpRect(0.0, 0.0, Data.Width, Data.Height);
//  sr := GpRect(0.0, 0.0, layoutRect.Width + ShadowSize * 2 + 2,
//               layoutRect.Height + ShadowSize * 2 + 2);
  dr := GpRect(layoutRect.Point, sr.Size);
  // 根据角度计算阴影位图在目标画布的偏移量
  Offset(dr, Cos(PI * Angle / 180) * Distance - ShadowSize - 1,
         Sin(PI * Angle / 180) * Distance - ShadowSize - 1);
  // 输出阴影位图到目标画布
  g.DrawImage(Bitmap, dr, sr.X, sr.Y, sr.Width, sr.Height, utPixel);
end;

// 计算并输出文字阴影效果
// g: 文字输出的画布; str要输出的文字; font: 字体; layoutRect: 限定的文字输出范围
// ShadowSize: 阴影大小; Distance: 阴影距离;
// Angle: 阴影输出角度(左边平行处为0度。顺时针方向)
// ShadowAlpha: 阴影文字的不透明度; format: 文字输出格式
procedure DrawShadowString(const g: TGpGraphics; const str: WideString;
    const font: TGpFont; const layoutRect: TGpRectF;
    ShadowSize, Distance: LongWord; Angle: Single = 60;
    Color: TARGB = $C0000000; Expand: LongWord = 0;
    const format: TGpStringFormat = nil); overload;
var
  Bmp: TGpBitmap;
  Bg: TGpGraphics;
begin
  // 建立透明的32位ARGB阴影位图，大小为layoutRect长、宽度 + ShadowSize * 2 + 2
  Bmp := TGpBitmap.Create(Round(layoutRect.Width + 0.5) + ShadowSize shl 1 + 2,
                          Round(layoutRect.Height + 0.5) + ShadowSize shl 1 + 2,
                          pf32bppARGB);
  Bg := TGpGraphics.Create(Bmp);
  try
    Bg.TextRenderingHint := thAntiAlias;
    // 以Color不透明度的黑色画刷，在ShadowSize + 1处输出文字到位图画布。
    // 方便黑色以外的阴影颜色替换（直接用Color画，模糊处理后很难看）
    Bg.DrawString(str, font, Brushs[Color and $FF000000],
                  GpRect(ShadowSize + 1, ShadowSize + 1,
                  layoutRect.Width, layoutRect.Height), format);
    DrawShadow(g, Bmp, layoutRect, ShadowSize, Distance, Angle, Color, Expand);
  finally
    Bg.Free;
    Bmp.Free;
  end;
end;

// 计算并输出文字阴影效果，除以输出点origin替代上面布局矩形外，其他参数同上
procedure DrawShadowString(const g: TGpGraphics; const str: WideString;
    const font: TGpFont; const origin: TGpPointF;
    ShadowSize, Distance: LongWord; Angle: Single = 60;
    Color: TARGB = $C0000000; Expand: LongWord = 0;
    const format: TGpStringFormat = nil); overload;
begin
  DrawShadowString(g, str, font, g.MeasureString(str, font, origin, format),
                   ShadowSize, Distance, Angle, Color, Expand, format);
end;
    上面代码中MakeShadow过程的代码在《GDI+ 在Delphi程序的应用 -- 可调节的文字阴影特效》一文中，本文没有贴出。由于代码中已经有了较详细的注释，故不再解释。下面贴出测试代码：

procedure TextPaint(g: TGpGraphics);
var
  brush: TGpLinearGradientBrush;
  font: TGpFont;
  fontFamily: TGpFontFamily;
  r: TGpRect;
begin
  fontFamily := TGpFontFamily.Create({'Times New Roman'}'华文行楷');
  font := TGpFont.Create(fontFamily, 55, [fsBold], utPixel);
  r := GpRect(Form1.PaintBox1.ClientRect);
  brush := TGpLinearGradientBrush.Create(r, kcBlue, kcAliceBlue, 90);
  g.FillRectangle(Brush, r);

  DrawShadowString(g, '文字阴影特效', font, GpPoint(10, r.Height / 3), 5, 10, 60, $C0000000, 1);
  DrawShadowString(g, '文字阴影特效', font, GpPoint(10, r.Height / 3), 1, 0, 60, $FFFF0000, 1);

//  DrawShadowString(g, '文字阴影特效', font, GpPoint(10, r.Height / 3), 5, 12, 60, $C0000000, 1);
//  DrawShadowString(g, '文字阴影特效', font, GpPoint(10, r.Height / 3), 2, 3, 60, $FFc00000, 1);
  g.TextRenderingHint := thAntiAlias;
  g.DrawString('文字阴影特效', font, Brushs.White, 10, r.Height / 3);
  font.Free;
  fontFamily.Free;
  Brush.Free;
end;
    以下是测试代码效果图，图一和图二都是文字描边（1个像素的边框）加阴影效果，其中图一没进行阴影扩展，即上面的15行的代码最后一个参数为0，图二是加了1个像素的阴影扩展效果（上述代码的“正宗”输出）：

 图一

图二

    利用改进的阴影效果，不仅可实现文字描边，也可显示类似立体文字的效果（改变显示距离），上面测试代码中，被注释的2句代码输出效果如下：

图三

    至于图像的描边，似乎没有文字的描边效果好，究其原因，主要是图像的轮廓看起来好像是圆润平滑的，其实有很多半影锯齿，在Photoshop中，通过先选区后描边，可能对选区边缘作了处理，所以效果相当好（专业的软件，肯定有很好的算法）。下面是我对一张小图片作的描边处理代码和输出效果图：

// 图像描边
// g: 文字输出的画布; Image: 图像; x, y: 图像输出原点
// BorderWidth: 总的边框宽度; Color: 边框颜色;
// Expand: 边框扩散大小; Attributes: 图像显示属性
procedure DrawImageBorder(const g: TGpGraphics; const Image: TGpImage;
    x, y: Single; BorderWidth: LongWord; Color: TARGB = kcWhite;
    Expand: LongWord = 0; const Attributes: TGpImageAttributes = nil);
var
  Bmp: TGpBitmap;
  Bg: TGpGraphics;
  ColorMatrix: TColorMatrix;
  Attr: TGpImageAttributes;
  layoutRect: TGpRectF;
begin
  Bmp := TGpBitmap.Create(Image.Width + BorderWidth shl 1 + 2,
                          Image.Height + BorderWidth shl 1 + 2,
                          pf32bppARGB);
  Bg := TGpGraphics.Create(Bmp);
  Attr := Attributes;
  if Attr = nil then
    Attr := TGpImageAttributes.Create;
  try
    FillChar(ColorMatrix, Sizeof(TColorMatrix), 0);
    ColorMatrix[3, 3] := 1;
    ColorMatrix[4, 4] := 1;
    // 利用颜色矩阵将图像输出为黑色，以便边框颜色替换
    Attr.SetColorMatrix(ColorMatrix);
    layoutRect := GpRect(x, y, Image.Width, Image.Height);
    Bg.DrawImage(Image,
                 GpRect(BorderWidth + 1, BorderWidth + 1, layoutRect.Width, layoutRect.Height),
                 0, 0, layoutRect.Width, layoutRect.Height, utPixel, Attr);
    DrawShadow(g, Bmp, layoutRect, BorderWidth, 0, 0, Color, BorderWidth - Expand);
  finally
    if Attributes <> nil then
      Attr.ClearColorMatrix
    else
      Attr.Free;
    Bg.Free;
    Bmp.Free;
  end;
end;

procedure ImagePaint(g: TGpGraphics);
var
  brush: TGpLinearGradientBrush;
  r: TGpRect;
  Image: TGpImage;
  Attributes: TGpImageAttributes;
begin
  r := GpRect(Form1.PaintBox1.ClientRect);
  brush := TGpLinearGradientBrush.Create(r, kcBlue, kcAliceBlue, 90);
  g.FillRectangle(Brush, r);
  Image := TGpImage.Create('..\..\Media\Watermark.bmp');
  // 画原图
  g.TranslateTransform(20, r.Height / 3);
  g.DrawImage(Image, 0, 0, Image.Width, Image.Height);
  // 设置图像透明色
  Attributes := TGpImageAttributes.Create;
  Attributes.SetColorKey($ff00ff00, $ff00ff00);
  // 画2个像素的描边图
  g.TranslateTransform(Image.Width + 20, 0);
  DrawImageBorder(g, Image, 0, 0, 2, kcWhite, 0, Attributes);
  g.DrawImage(Image, GpRect(0.0, 0, Image.Width, Image.Height),
              0.0, 0.0, Image.Width, Image.Height, utPixel, Attributes);
  // 画5个像素的描边图，其中扩散3像素
  g.TranslateTransform(Image.Width + 20, 0);
  DrawImageBorder(g, Image, 0, 0, 5, kcWhite, 3, Attributes);
  g.DrawImage(Image, GpRect(0.0, 0, Image.Width, Image.Height),
              0.0, 0.0, Image.Width, Image.Height, utPixel, Attributes);
  Attributes.Free;
  Brush.Free;
  Image.Free;
end;

图四

    上面的效果图中，左边是原图，中间是2个像素的描边图，右边是5个像素的描边图，其中有3像素的模糊扩散。从图中可以看出，我以$ff00ff00为透明色处理图像四个角后，在中间和右边的描边图中，还是很明显的看到四个角有很淡的绿色，正是这个原因，在中间图的圆角描边有明显的锯齿。

    最后作几点说明：

    1、本文纯属业余学习和研究的心得，并非什么正宗的算法；

    2、因为本文代码是学习时即兴写的，并非优化代码，而且是以过程形式出现的，有兴趣的朋友可以自己进行优化改进，写成类或者元件更好（由于算法和功能都不是很完善，所以我没写成类的形式）；

    3、例子中的GDI+版本系本人自己改写的，与网上流通的版本不完全兼容，如需使用本版本，请参照《GDI+ for VCL基础 -- GDI+ 与 VCL 》一文的下载地址，并请留意后面的修改说明。

    4、如有好的建议，请来信：maozefa@hotmail.com

    更新(2008-8-5 12:50)：在MakeExpand过程中，是按图象逐点用位图画笔矩阵填充的，每个像素点都要进行矩阵大小的操作，最小的1像素扩展的矩阵大小为3 * 3，可见扩展速度是不大理想的。今天对代码作了一点修改，对每个象素点都进行了判断，如果是边界像素，则作画笔矩阵填充，否则直接跳过，这样一来，速度应该提高不少（没作测试，增加的代码用红色标出，有兴趣者可以测试）。

 
原作者相关文章：
GDI+ 在Delphi程序的应用 -- 可调节的文字阴影特效
GDI+在Delphi程序的应用 – Photoshop色相/饱和度/明度功能