php的GD2绘出的图形默认从左上角开始，怎样让绘

应用GD2函数可以绘制的图形有多种，最基本的图形包括条、圆、方形等。无论开发人员绘制多么复杂的图形，都是在这些最基本的图形的基础上进行深化的，只有掌握了最基本的图形的绘制方法，才能绘制出各种具有独特风格的图形。

在GD2中可以分别应用imageline()函数、imagearc()函数和imagerectangle()函数绘制直线，圆形和方法。

下面将介绍这些函数的使用方法：

bool imageline( resource image, int x1, int y1, int x2, int y2, int color )

imageline()函数用color颜色在图像image中从坐标(x1,y1)到(x2,y2)（图像左上角为(0,0)）绘制一条线段。

bool imagearc( resource image, int cx, int cy, int w, int h, int s, int e, int color)

image : 表示图像的handle

cx,cy 原点坐标(0,0)为的左上角，参数cx,cy为椭圆圆心坐标

w,h分别为水平轴长和垂直轴长

s,e分别为起始角与结束角

color为弧线的颜色

bool imagerectangle( resource image, int x1, int y1, int x2, int y2, int color)

imagerectangle()函数以color颜色在image图像中绘制一个矩形，其左上角坐标为( x1,y1)，右下角坐标为( x2, y2)。图像的左上角坐标为(0,0)

标定

通过相机的标定得到相机内参和外参和畸变系数。

内参矩阵

一般用A或者M1表示。内参矩阵含有相机的固有参数（fx，fy，Cx，Cy），fx，fy（单位：像素）与dx，dy（x,y方向一个像素的物理尺寸，单位：毫米/像素）和焦距f（单位：毫米）有关。 Cx，Cy为图像原点相对于光心成像点的纵横偏移量（单位：像素）。

相机坐标系转图像坐标系

3D恢复

外参矩阵

一般用[R|T]表示，R表示旋转矩阵，T为平移矩阵。不同的棋盘图对应不同的旋转矩阵和平移矩阵。因为每一副图像对应的世界坐标系相对应与相机坐标系是不一样的。

世界坐标系转相机坐标系

图像校正（倾斜，平移）

畸变系数

一般用[p1,p2,p3,k1,k2]表示，p1,p2,p3是相机的径向畸变系数，k1,k2是相机的切向畸变系数。

图像矫正（T型畸变，鱼眼图像等）

标定步骤

拍摄棋盘图，越多越好，一般10张就可以，10张必须符合所有角点都能检测到才算合格棋盘图。

标定程序计算并保存相机内参和外参和畸变系数矩阵，

运用三个矩阵解决实际问题。只要相机的角度和焦距固定，位置可以移动，那么内参矩阵和畸变系数是不会改变的。

注意：

单目标定的外参矩阵，运用只能对应相应的棋盘的世界坐标系。

双目标定可以确定唯一的外参矩阵。

坐标系

相机坐标系

以光心为相机坐标系的原点，以平行于图像的x和y方向为Xc轴和Yc轴，Zc轴和光轴平行，Xc，Yc，Zc互相垂直，单位是长度单位

图像物理坐标系

可以认为是相机坐标系z轴方向的投影图。以主光轴和图像平面交点为坐标原点，注意：不一定是图像的中心点，根据Cx和Cy知道偏移了多少像素。图像物理坐标系x和y方向单位是长度单位。

图像坐标系

以主光轴和图像平面交点为坐标原点，x和y方向单位是像素单位。

世界坐标系

物体在真实世界中的坐标，比如黑白棋盘格的世界坐标系原点定在第一个棋盘格的顶点，Xw，Yw，Zw互相垂直，Zw方向就是垂直于棋盘格面板的方向。可见世界坐标系是随着物体的大小和位置变化的，单位是长度单位。只要棋盘格的大小决定了，无论板子怎么动，棋盘格角点坐标一般就不再变动(因为是相对于世界坐标系原点的位置不变)，且认为是Zw=0。

我们之前都是图像分类的任务，最后一个全连接层得到所有分类的得分。现在我们来研究计算机视觉的其他任务，比如语义分割、图像分类与定位、目标检测、实例分割等。

在 语义分割 任务中，输入一张，希望输出能对图像的每个像素做出分类，判断这个像素是属于物体或者背景，不再像之前那样整张都是一个类。语义分割不会区分实例，只关心像素，所以如果图中有两头牛，会把两块像素都归为牛，不会分开每一头，以后会讲到 实例分割 （Instance Segmentation）可以区分实例。

实现语义分割的一个想法是 滑动窗口 ，即将图像分成一个个的小块，然后使用CNN网络计算小块的中心元素属于哪个分类。这样做的一个问题是，需要为每个像素计算一次，很多运算都是重复的，实际上没人会这么做。

另一个想法是 全卷积 （ Fully Convolutional），将网络的所有层都设计成卷积层，这样就能实现一次对图像的所有像素进行预测。比如使用3x3的卷积层然后使用零填充保持输入输出的空间尺寸，最终得到一个CxHxW的特征图，其中C是像素分类的数量，这样的一个特征图就一次计算了所有像素的分类得分。然后使用交叉熵损失、取平均、反向传播等 *** 作进行训练。由于要为每个像素设置标签，这样的数据集花费是非常昂贵的。这里的数据集需要先确定图像属于哪个类别，比如猫，然后对图像的像素点设置类别。实际应用中，如果一直保持空间尺寸的话计算量会很庞大，所以不能设置这种结构。

使用全卷积网络的一种好的形式是在网络内部使用 降采样 （downsampling）然后使用 升采样 （upsampling），只在最初的几个卷积层保持尺寸，然后降采样比如池化或跨进卷积（strided convolution）来降低尺寸，进行一系列卷积后升采样到原来的尺寸。之所以需要去池化是因为池化减少了像素值，降低了图像的清晰度，丢失了图像空间结构，不知道这些像素原来在哪里，所以也就不明确边界应该在什么位置，所以需要进行去池化得到这些空间信息。

然后问题是如何进行升采样呢？

在一维中可能会表现的更清晰：滤波器被输入加权后直接放到输出中，输出的步长为2，下一个位置要平移两个像素，重叠的部分直接相加。最后为了使输出是输入的两倍，需要裁掉一个像素。

之所以称作转置卷积，可以通过矩阵乘法来解释，以一个一维的输入为例 a = [a, b, c, d]，现在做 3x1 的卷积，卷积核为 [x, y, z]，步长1填充1，此时的卷积可以看作是卷积核组成的一个大的矩阵 X 与输入 a 做乘法，如下图左边所示。（图上应为xyz，书写错误。）卷积核在输入 a 上滑动对应元素相乘后相加得到输出的过程，完全等价于卷积核组成的大矩阵与输入 a 的乘法。然后将 X 转置与 a 相乘，即转置卷积，结果就是一个正常的卷积，改变的只是填充规则。

现在如果步长为2，情况就不一样了。左边的卷积仍然可以看作是乘法，而右侧的转置卷积就变成用输入加权后的卷积核在输出上的叠加。

综上，语义分割任务的实现方法如下图所示：

此外， 多视角3D重建 （ Multi-view 3D Reconstruction）也使用了降采样和升采样的方法。

定位 （ Localization）往往是与 分类 （Classificatio）结合在一起的，如果分类是一只猫，同时我们也想知道猫在这张的什么位置，要用一个框给框起来。这与 目标检测 （Object Detection）是不同的，定位是一旦图像已经归为哪一类，比如猫，这样我们就会有一个明确的目标去寻找，找出它的边界即可。而目标检测是要检测出图像上存在的物体。

定位可以复用分类的方法，比如AlexNet。如下图所示，最后一个全连接层，除了得到1000个类别的得分，还会得到一个长为4的向量，表示目标的位置。这样最后就有两个损失，一个是正确分类的Softmax损失，另一个是正确位置的L2损失，L1、L2等损失也称作 回归损失 （Regression Loss）。最后将两个损失通过某些超参数加权得到总损失，和之前的超参数不同的是，以前的超参数改变是为了减小损失，而这里的加权超参数直接会改变损失值的表达式，损失变大变小都有可能。使用总损失求梯度。这里使用的网络是使用ImageNet 预训练过的模型，进行迁移学习。

目标检测任务是这样的：我们有几个感兴趣的类别，比如猫狗鱼等等，现在输入一张图像，图像上有几个物体事先是不知道的，当我们我们感兴趣的物体在图像上出现时，我们希望模型能自动标记出目标物体的位置，并判断出具体的分类。这实际上是很有挑战的任务，也是计算机视觉中很核心的任务，对此的研究已经经历了很多年，也有非常多的方法。

与定位最大的区别是，我们不知道图上会有多少对象。比如图像上只有一只猫，我们最终的输出只有一个位置四个数字；有两只狗一只猫，会输出3个位置12个数字；那么有一群鸭子呢？数量就很多了。所以目标检测问题不能看作定位中的回归问题。

另一个想法是把目标检测问题看作分类问题。类似语义分割的想法，将图像分成一个个的小块，让每一个小块通过卷积网络判断这块是背景？是猫？是狗？可以这么想，但是这个小块该怎么获得呢？不同的物体可能会有不同的大小、位置以及长宽比，这将是无数的情况，如果都要进行卷积，那么计算量是非常大的。

实际上，更实用的方法是 候选区域 （Region Proposals ）方法。 选择性搜索 （Selective Search ）方法就是在目标对象周围设定2000个形状大小位置不一的候选区域，目标物体在候选区域的可能性还是比较大的。然后对这些区域卷积，找到目标物体，虽然大多数区域都是无用的。与寻找几乎个区域比起来，这种方法要高效的多。此外，这不是深度学习的方法，是机器学习算法。 R-CNN 就是基于这种观点提出的。首先对输入使用区域备选算法，获取2000个感兴趣的区域（Regions of interest, roi），由于这些区域大小不一，所以需要处理成同样的尺寸才能通过CNN，之后使用SVM对区域进行分类。可以使用线性回归损失来校正包围框，比如虽然这个框选中的物体是一个缺少头部的狗，就需要对包围框进行校正。总之，这是一个多损失网络。

R-CNN的问题是计算消耗大、磁盘占用多、运行速度慢，即使测试时也要30秒测试一张，因为有2000个区域。解决方法时使用 快速R-CNN （Fast R-CNN ），不在原始图像生成备选区域，而是先整张通过卷积网络得到特征图，然后在特征图上使用备选区域算法得到感兴趣的区域在特征图的映射，之后使用 Rol Pool将所有区域变成同样尺寸。然后一方面使用softmax损失进行分类，一方面使用回归损失比如L1平滑损失校正包围框，总损失是两部分的和，然后反向传播进行训练。

如下图所示，效果还是很明显的。但是快速R-CNN也有一个问题是运行时间被区域备选方案限制。

解决方案是 更快的R-CNN (Faster R-CNN)。这种方法的改进是与其使用固定的算法得到备选区域，不如让网络自己学习自己的备选区域应该是什么。如下图所示，前面仍然是通过卷积网络获得特征图，然后通过一个 备选区域网络 （Region Proposal Network，RPN），该网络会做两件事，一是计算分类损失，选择的区域是目标还是不是目标；二是校正包围框。得到备选区域后接下来的步骤就和快速R-CNN一致了，也是得到最后的分类得分和校正包围框。训练的过程会综合这四个损失，最终效果很好。

Mask R-CNN是在Faster R-CNN基础上改进而来，是2017年发布的方法。首先将整张图像通过卷积网络和候选框生成网络，得到候选特征在特征图上的映射再调整尺寸，到这里和Faster R-CNN都是相同的；现在不仅是得到分类得分和校正包围框，还要增加一个分支通过卷积网络对每一个候选框预测一个分割区域模板。这个新增的分支就是一个在候选框中进行的微型语义分割任务。这样上下两个分支的任务就很明确了——上面的分支需要计算分类得分确定候选框中的目标属于哪个分类以及通过对候选框坐标的回归来预测边界框的坐标；下面的分支基本类似一个微型语义分割网络，会对候选框中的每个像素进行分类，判断每个像素是否属于候选框的中目标。

Mask R-CNN综合了上面讲的很多方法，最终的效果也是非常好的。比如下图最左边，不仅框出了每个物体还分割了像素，即使很远地方的人也被清晰的分割出来了。

此外，Mask R-CNN也可以识别动作，方法是在上面分支中增加一个关节坐标损失，这样就能同时进行分类、检测、动作识别、语义分割。此外，基于Faster R-CNN，运行速度也是非常快的。下图展示的效果是很令人惊讶的，可以同时识别出图上有多少人，分割出他们的像素区域，并且会标示他们的动作姿势。

使用前馈模型。

YOLO 即 “You Only Look Once” 和 SSD 即 “Single-Shot MultiBox Detector”，这两个模型是在同一时期提出的（2016），它们不会使用候选框分别进行处理，而是尝试将其作为回归问题，通过一个大的卷积网络，一次完成所有预测。给定输入图像，分成网格状比如7x7，然后在每个小单元中心处使用 B 个基本的边界框，比如高的、宽的、正方形的，这样总共有 7x7xB个基本框。现在想对每个网格单元的所有基本边界框预测目标物体，首先要预测每个基本边界框偏移来确定边界框和真实物体的位置差值，使用5个值（dx, dy, dh, dw, confidence）来表示偏差；然后预测每个网格单元里目标的 C 个分类（包括背景）得分，这样每个网格单元都会得到一个分类得分，即目标所属类别。最终的输出就是一个三维的张量：7x7x(5B+C)。

TensorFlow Detection API（Faster RCNN, SSD, RFCN, Mask R-CNN）： 点击这里

二维平面的目标检测只需确定 [x, y, w, h]，3D的定位框需要确定的坐标为 [x, y, z, roll, pitch, yaw]，简化后可以不需要 roll 和 pitch。比2D目标检测要复杂的多。

Matlab上有CANNY算子的库函数啊，直接调用就行了。

我这有VC++的边缘检测算法，很长的。稍微改一下就可以用在Matlab上。

/ 一维高斯分布函数，用于平滑函数中生成的高斯滤波系数

void CFunction::CreatGauss(double sigma, double pdKernel, int pnWidowSize)

{

LONG i;

//数组中心点

int nCenter;

//数组中一点到中心点距离

double dDis;

//中间变量

double dValue;

double dSum;

dSum = 0;

// [-3sigma,3sigma] 以内数据，会覆盖绝大部分滤波系数

pnWidowSize = 1+ 2ceil(3sigma);

nCenter = (pnWidowSize)/2;

pdKernel = new double[pnWidowSize];

//生成高斯数据

for(i=0;i<(pnWidowSize);i++)

{

dDis = (double)(i - nCenter);

dValue = exp(-(1/2)dDisdDis/(sigmasigma))/(sqrt(231415926)sigma);

(pdKernel)[i] = dValue;

dSum+=dValue;

}

//归一化

for(i=0;i<(pnWidowSize);i++)

{

(pdKernel)[i]/=dSum;

}

}

//用高斯滤波器平滑原图像

void CFunction::GaussianSmooth(SIZE sz, LPBYTE pGray, LPBYTE pResult, double sigma)

{

LONG x, y;

LONG i;

//高斯滤波器长度

int nWindowSize;

//窗口长度

int nLen;

//一维高斯滤波器

double pdKernel;

//高斯系数与图像数据的点乘

double dDotMul;

//滤波系数总和

double dWeightSum;

double pdTemp;

pdTemp = new double[szcxszcy];

//产生一维高斯数据

CreatGauss(sigma, &pdKernel, &nWindowSize);

nLen = nWindowSize/2;

//x方向滤波

for(y=0;y<szcy;y++)

{

for(x=0;x<szcx;x++)

{

dDotMul = 0;

dWeightSum = 0;

for(i=(-nLen);i<=nLen;i++)

{

//判断是否在图像内部

if((i+x)>=0 && (i+x)<szcx)

{

dDotMul+=(double)pGray[yszcx+(i+x)] pdKernel[nLen+i];

dWeightSum += pdKernel[nLen+i];

}

}

pdTemp[yszcx+x] = dDotMul/dWeightSum;

}

}

//y方向滤波

for(x=0; x<szcx;x++)

{

for(y=0; y<szcy; y++)

{

dDotMul = 0;

dWeightSum = 0;

for(i=(-nLen);i<=nLen;i++)

{

if((i+y)>=0 && (i+y)< szcy)

{

dDotMul += (double)pdTemp[(y+i)szcx+x]pdKernel[nLen+i];

dWeightSum += pdKernel[nLen+i];

}

}

pResult[yszcx+x] = (unsigned char)(int)dDotMul/dWeightSum;

}

}

delete []pdKernel;

pdKernel = NULL;

delete []pdTemp;

pdTemp = NULL;

}

// 方向导数,求梯度

void CFunction::Grad(SIZE sz, LPBYTE pGray,int pGradX, int pGradY, int pMag)

{

LONG y,x;

//x方向的方向导数

for(y=1;y<szcy-1;y++)

{

for(x=1;x<szcx-1;x++)

{

pGradX[yszcx +x] = (int)( pGray[yszcx+x+1]-pGray[yszcx+ x-1] );

}

}

//y方向方向导数

for(x=1;x<szcx-1;x++)

{

for(y=1;y<szcy-1;y++)

{

pGradY[yszcx +x] = (int)(pGray[(y+1)szcx +x] - pGray[(y-1)szcx +x]);

}

}

//求梯度

//中间变量

double dSqt1;

double dSqt2;

for(y=0; y<szcy; y++)

{

for(x=0; x<szcx; x++)

{ //二阶范数求梯度

dSqt1 = pGradX[yszcx + x]pGradX[yszcx + x];

dSqt2 = pGradY[yszcx + x]pGradY[yszcx + x];

pMag[yszcx+x] = (int)(sqrt(dSqt1+dSqt2)+05);

}

}

}

//非最大抑制

void CFunction::NonmaxSuppress(int pMag, int pGradX, int pGradY, SIZE sz, LPBYTE pNSRst)

{

LONG y,x;

int nPos;

//梯度分量

int gx;

int gy;

//中间变量

int g1,g2,g3,g4;

double weight;

double dTmp,dTmp1,dTmp2;

//设置图像边缘为不可能的分界点

for(x=0;x<szcx;x++)

{

pNSRst[x] = 0;

//pNSRst[(szcy-1)szcx+x] = 0;

pNSRst[szcy-1+x] = 0;

}

for(y=0;y<szcy;y++)

{

pNSRst[yszcx] = 0;

pNSRst[yszcx + szcx-1] = 0;

}

for(y=1;y<szcy-1;y++)

{

for(x=1;x<szcx-1;x++)

{ //当前点

nPos = yszcx + x;

//如果当前像素梯度幅度为0，则不是边界点

if(pMag[nPos] == 0)

{

pNSRst[nPos] = 0;

}

else

{ //当前点的梯度幅度

dTmp = pMag[nPos];

//x,y方向导数

gx = pGradX[nPos];

gy = pGradY[nPos];

//如果方向导数y分量比x分量大，说明导数方向趋向于y分量

if(abs(gy) > abs(gx))

{

//计算插值比例

weight = fabs(gx)/fabs(gy);

g2 = pMag[nPos-szcx];

g4 = pMag[nPos+szcx];

//如果x,y两个方向导数的符号相同

//C 为当前像素，与g1-g4 的位置关系为：

//g1 g2

// C

// g4 g3

if(gxgy>0)

{

g1 = pMag[nPos-szcx-1];

g3 = pMag[nPos+szcx+1];

}

//如果x,y两个方向的方向导数方向相反

//C是当前像素，与g1-g4的关系为：

// g2 g1

// C

// g3 g4

else

{

g1 = pMag[nPos-szcx+1];

g3 = pMag[nPos+szcx-1];

}

}

//如果方向导数x分量比y分量大，说明导数的方向趋向于x分量

else

{

//插值比例

weight = fabs(gy)/fabs(gx);

g2 = pMag[nPos+1];

g4 = pMag[nPos-1];

//如果x,y两个方向的方向导数符号相同

//当前像素C与 g1-g4的关系为

// g3

// g4 C g2

// g1

if(gx gy > 0)

{

g1 = pMag[nPos+szcx+1];

g3 = pMag[nPos-szcx-1];

}

//如果x,y两个方向导数的方向相反

// C与g1-g4的关系为

// g1

// g4 C g2

// g3

else

{

g1 = pMag[nPos-szcx+1];

g3 = pMag[nPos+szcx-1];

}

}

//利用 g1-g4 对梯度进行插值

{

dTmp1 = weightg1 + (1-weight)g2;

dTmp2 = weightg3 + (1-weight)g4;

//当前像素的梯度是局部的最大值

//该点可能是边界点

if(dTmp>=dTmp1 && dTmp>=dTmp2)

{

pNSRst[nPos] = 128;

}

else

{

//不可能是边界点

pNSRst[nPos] = 0;

}

}

}

}

}

}

// 统计pMag的直方图，判定阈值

void CFunction::EstimateThreshold(int pMag, SIZE sz, int pThrHigh, int pThrLow, LPBYTE pGray,

double dRatHigh, double dRatLow)

{

LONG y,x,k;

//该数组的大小和梯度值的范围有关，如果采用本程序的算法

//那么梯度的范围不会超过pow(2,10)

int nHist[1024];

//可能边界数

int nEdgeNum;

//最大梯度数

int nMaxMag;

int nHighCount;

nMaxMag = 0;

//初始化

for(k=0;k<1024;k++)

{

nHist[k] = 0;

}

//统计直方图,利用直方图计算阈值

for(y=0;y<szcy;y++)

{

for(x=0;x<szcx;x++)

{

if(pGray[yszcx+x]==128)

{

nHist[pMag[yszcx+x]]++;

}

}

}

nEdgeNum = nHist[0];

nMaxMag = 0;

//统计经过“非最大值抑制”后有多少像素

for(k=1;k<1024;k++)

{

if(nHist[k] != 0)

{

nMaxMag = k;

}

//梯度为0的点是不可能为边界点的

//经过non-maximum suppression后有多少像素

nEdgeNum += nHist[k];

}

//梯度比高阈值pThrHigh 小的像素点总书目

nHighCount = (int)(dRatHigh nEdgeNum + 05);

k=1;

nEdgeNum = nHist[1];

//计算高阈值

while((k<(nMaxMag-1)) && (nEdgeNum < nHighCount))

{

k++;

nEdgeNum += nHist[k];

}

pThrHigh = k;

//低阈值

pThrLow = (int)((pThrHigh) dRatLow + 05);

}

//利用函数寻找边界起点

void CFunction::Hysteresis(int pMag, SIZE sz, double dRatLow, double dRatHigh, LPBYTE pResult)

{

LONG y,x;

int nThrHigh,nThrLow;

int nPos;

//估计TraceEdge 函数需要的低阈值，以及Hysteresis函数使用的高阈值

EstimateThreshold(pMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow);

//寻找大于dThrHigh的点，这些点用来当作边界点，

//然后用TraceEdge函数跟踪该点对应的边界

for(y=0;y<szcy;y++)

{

for(x=0;x<szcx;x++)

{

nPos = yszcx + x;

//如果该像素是可能的边界点，并且梯度大于高阈值，

//该像素作为一个边界的起点

if((pResult[nPos]==128) && (pMag[nPos] >= nThrHigh))

{

//设置该点为边界点

pResult[nPos] = 255;

TraceEdge(y,x,nThrLow,pResult,pMag,sz);

}

}

}

//其他点已经不可能为边界点

for(y=0;y<szcy;y++)

{

for(x=0;x<szcx;x++)

{

nPos = yszcx + x;

if(pResult[nPos] != 255)

{

pResult[nPos] = 0;

}

}

}

}

//根据Hysteresis 执行的结果，从一个像素点开始搜索，搜索以该像素点为边界起点的一条边界的

//一条边界的所有边界点，函数采用了递归算法

// 从（x,y)坐标出发，进行边界点的跟踪，跟踪只考虑pResult中没有处理并且可能是边界

// 点的像素（=128），像素值为0表明该点不可能是边界点，像素值为255表明该点已经是边界点

void CFunction::TraceEdge(int y, int x, int nThrLow, LPBYTE pResult, int pMag, SIZE sz)

{

//对8邻域像素进行查询

int xNum[8] = {1,1,0,-1,-1,-1,0,1};

int yNum[8] = {0,1,1,1,0,-1,-1,-1};

LONG yy,xx,k; //循环变量

for(k=0;k<8;k++)

{

yy = y+yNum[k];

xx = x+xNum[k];

if(pResult[640 (479 - yy)+xx]==128 && pMag[640 (479 - yy)+xx]>=nThrLow )

{

//该点设为边界点

pResult[640 (479 - yy)+xx] = 255;

//以该点为中心再进行跟踪

TraceEdge(yy,xx,nThrLow,pResult,pMag,sz);

}

}

}

// Canny算子

BOOL CFunction::Canny(LPBYTE m_pDibData,CPoint ptLeft, CPoint ptRight , double sigma, double dRatLow, double dRatHigh)

{

BYTE m_Newdata;//每一步处理后的图像数据

m_Newdata = (BYTE)malloc(maxImage);

memcpy(m_Newdata,(BYTE )m_pDibData,maxImage);

//经过抑制局部像素非最大值的处理后的数据

BYTE pResult;//每一步处理后的图像数据

pResult = (BYTE)malloc(maxImage);

memcpy(pResult,(BYTE )m_pDibData,maxImage);

int pointy,pointx,m,n,i=0;

long Position;

int GradHori;

int GradVert;

//存储结构元素的数组

BYTE array[9]={0};

//设定两个阈值

int nThrHigh,nThrLow;

//梯度分量

int gx;

int gy;

//中间变量

int g1,g2,g3,g4;

double weight;

double dTmp,dTmp1,dTmp2;

int Width,Higth;

Width=ptRightx-ptLeftx+1;

Higth=ptRighty-ptLefty+1;

CSize sz=CSize(Width,Higth);

//x方向导数的指针

int pGradX= new int[maxImage];

memset(pGradX,0,maxImage);

//y方向

int pGradY;

pGradY = new int [maxImage];

memset(pGradY,0,maxImage);

//梯度的幅度

int pGradMag;

pGradMag = new int [maxImage];

//对pGradMag进行初始化

for (pointy = 0;pointy <480;pointy++)

{

for (pointx = 0;pointx <640 ;pointx++)

{

Position=640 (479 - pointy)+pointx;

pGradMag[Position]=m_pDibData[Position];

}

}

//第一步进行高斯平滑器滤波

//进入循环,使用33的结构元素，处理除去第一行和最后一行以及第一列和最后一列。

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

Position=640 (479 - pointy)+pointx;

for (m = 0;m < 3;m++)

{

for (n = 0;n < 3;n++)

{

array[m3+n]=m_pDibData[Position+640(1-m)+n-1];

}

}

GradHori=abs(array[0]+2array[1]+array[2]+2array[3]+4array[4]+2array[5]+array[6]+2array[7]+array[8]);

GradHori=(int)(00625GradHori+05);

if (GradHori>255)

{

m_Newdata[Position]=255;

}

else

m_Newdata[Position]=GradHori;

}

}

//第二步用一阶偏导的有限差分来计算梯度的幅值和方向

//x方向的方向导数

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

pGradX[pointyWidth +pointx]=(int)(m_Newdata[pointyWidth +pointx+1]- m_Newdata[pointyWidth +pointx-1] );

}

}

//y方向方向导数

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

pGradY[pointyWidth +pointx] = (int)(m_Newdata[(pointy+1)Width +pointx] - m_Newdata[(pointy-1)Width +pointx]);

}

}

//求梯度

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

Position=640 (479 - pointy)+pointx;

for (m = 0;m < 3;m++)

{

for (n = 0;n < 3;n++)

{

array[m3+n]=m_Newdata[Position+640(1-m)+n-1];

}

}

GradHori=abs((-1)array[0]+(-2)array[3]+2array[7]+array[8]);

GradVert=abs((-1)array[0]-2array[1]+2array[5]+array[8]);

GradHori =(int)((float)sqrt(pow(GradHori,2)+pow(GradVert,2))+05);

pGradMag[Position]=GradHori;

}

}

//针对第一行的像素点及最后一行的像素点

for (pointx = ptLeftx;pointx <= ptRightx;pointx++)

{

Position=640 (479 - ptLefty)+pointx;

pGradMag[Position]=0;

Position=640 (479 - ptRighty)+pointx;

pGradMag[Position]=0;

}

//针对第一列以及最后一列的像素点

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

Position=640 (479 - pointy)+ptLeftx;

pGradMag[Position]=0;

Position=640 (479 - pointy)+ptRightx;

pGradMag[Position]=0;

}

//第三步进行抑制梯度图中的非局部极值点的像素

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{ //当前点

Position=640 (479 - pointy)+pointx;

//如果当前像素梯度幅度为0，则不是边界点

if(pGradMag[Position] == 0)

{

pGradMag[Position] = 0;

}

else

{ //当前点的梯度幅度

dTmp = pGradMag[Position];

//x,y方向导数

gx = pGradX[Position];

gy = pGradY[Position];

//如果方向导数y分量比x分量大，说明导数方向趋向于y分量

if(abs(gy) > abs(gx))

{

//计算插值比例

weight = fabs(gx)/fabs(gy);

g2 = pGradMag[Position-640];

g4 = pGradMag[Position+640];

//如果x,y两个方向导数的符号相同

//C 为当前像素，与g1-g4 的位置关系为：

//g1 g2

// C

// g4 g3

if(gxgy>0)

{

g1 = pGradMag[Position-640-1];

g3 = pGradMag[Position+640+1];

}

//如果x,y两个方向的方向导数方向相反

//C是当前像素，与g1-g4的关系为：

// g2 g1

// C

// g3 g4

else

{

g1 = pGradMag[Position-640+1];

g3 = pGradMag[Position+640-1];

}

}

//如果方向导数x分量比y分量大，说明导数的方向趋向于x分量

else

{

//插值比例

weight = fabs(gy)/fabs(gx);

g2 = pGradMag[Position+1];

g4 = pGradMag[Position-1];

//如果x,y两个方向的方向导数符号相同

//当前像素C与 g1-g4的关系为

// g3

// g4 C g2

// g1

if(gx gy > 0)

{

g1 = pGradMag[Position+640+1];

g3 = pGradMag[Position-640-1];

}

//如果x,y两个方向导数的方向相反

// C与g1-g4的关系为

// g1

// g4 C g2

// g3

else

{

g1 =pGradMag[Position-640+1];

g3 =pGradMag[Position+640-1];

}

}

//利用 g1-g4 对梯度进行插值

{

dTmp1 = weightg1 + (1-weight)g2;

dTmp2 = weightg3 + (1-weight)g4;

//当前像素的梯度是局部的最大值

//该点可能是边界点

if(dTmp>=dTmp1 && dTmp>=dTmp2)

{

pResult[Position] = 128;

}

else

{

//不可能是边界点

pResult[Position] = 0;

}

}

}

}

}

//第四步根据梯度计算及经过非最大值得印制后的结果设定阈值

//估计TraceEdge 函数需要的低阈值，函数使用的高阈值

EstimateThreshold(pGradMag, sz,&nThrHigh,&nThrLow,pResult,dRatHigh,dRatLow);

//寻找大于dThrHigh的点，这些点用来当作边界点，

//然后用TraceEdge函数跟踪该点对应的边界

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

Position=640 (479 - pointy)+pointx;

//如果该像素是可能的边界点，并且梯度大于高阈值，

//该像素作为一个边界的起点

if((pResult[Position]==128) && (pGradMag[Position] >= nThrHigh))

{

//设置该点为边界点

pResult[Position] = 255;

TraceEdge(pointy,pointx,nThrLow,pResult,pGradMag,sz);

}

}

}

//其他点已经不可能为边界点

for (pointy = ptLefty+1;pointy <= ptRighty-1;pointy++)

{

for (pointx = ptLeftx+1;pointx <= ptRightx-1;pointx++)

{

Position=640 (479 - pointy)+pointx;

if(pResult[Position] != 255)

{

pResult[Position] = 0;

}

}

}

//计算方向导数和梯度的幅度

// Grad(sz,pGaussSmooth,pGradX,pGradY,pGradMag);

//应用非最大抑制

// NonmaxSuppress(pGradMag,pGradX,pGradY,sz,pResult);

//应用Hysteresis，找到所有边界

// Hysteresis(pGradMag,sz,dRatLow,dRatHigh,pResult);

memcpy(m_pDibData,(BYTE )pResult,maxImage);

delete[] pResult;

pResult = NULL;

delete[] pGradX;

pGradX = NULL;

delete[] pGradY;

pGradY = NULL;

delete[] pGradMag;

pGradMag = NULL;

delete[] m_Newdata;

m_Newdata = NULL;

return true;

}

以上就是关于php的GD2绘出的图形默认从左上角开始，怎样让绘全部的内容，包括:php的GD2绘出的图形默认从左上角开始，怎样让绘、怎么理解相机的光圈中心 cx cy、Lecture 11 检测与分割等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！