opencv c++ canny 实现 以及与halcon canny的对比

news2024/12/25 9:15:54

Opencv和C++实现canny边缘检测_opencv边缘增强-CSDN博客

一、canny实现步骤

1、图像必须是单通道的，也就是说必须是灰度图像

2、图像进行高斯滤波，去掉噪点 

3、sobel 算子过程的实现，计算x y方向 、梯度（用不到，但是可以看看xy 两个组合起来的结果）

以及梯度方向（很重要）

4、局部非极大值抑制

5、双阈值连接处理

具体可以分为上面的5个步骤，下面一起边看原理边实现。

二、原理与实现

1、图像灰度化

如果是一张3通道的图像，也就是我们常见的彩色图，那么们就需要将其转换成一个灰度图，其规则如下：

             1.浮点算法：Gray = R*0.3 + G*0.59 + B*0.11
　　  2.整数方法：Gray = (R*30+G*59+B*11)/100
　　  3.移位方法：Gray = (R*28+G*151+B*77）>> 8
　　  4.平均值法：Gray = (R+G+B)/3
　　  5.仅取绿色：Gray = G
但是通常我们自己实现一般都是拿第一种实现的。

OpenCV转灰度图像特别简单，只需调用函数 cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) 即可。

code：

void ConvertRGB2GRAY(const Mat& image, Mat& imageGray)
{
	if (!image.data || image.channels() != 3)
	{
		return;
	}
	// 创建一个单通道的灰度图像
	imageGray = Mat::zeros(image.size(), CV_8UC1);

	//  取出存储图像的数组的指针 
	uchar* pointImage = image.data;
	uchar* pointImageGray = imageGray.data;

	int stepImage = image.step;
	int stepImageGray = imageGray.step;
	for (int i = 0; i < imageGray.rows; i++)
	{
		for (int j = 0; j < imageGray.cols; j++)
		{
			pointImageGray[i * stepImageGray + j] = 0.114 * pointImage[i * stepImage + 3 * j] + 0.587 * pointImage[i * stepImage + 3 * j + 1] + 0.299 * pointImage[i * stepImage + 3 * j + 2];
		}
	}
}

2、高斯滤波

在高斯滤波的时候先要生成一个2元高斯核，然后进行高斯滤波，其作用是去掉噪点，其图像变的平滑起来

二元高斯函数

  随着sigma的增大，整个高斯函数的尖峰逐渐减小，整体也变的更加平缓，则对图像的平滑效果越来越明显。

高斯核

代码里面最后一定要归一化


void  CreateGaussianKernel(int  kernel_size, int sigma, Mat& kernel)
{
	const   double  PI = 3.1415926;
	int  center = kernel_size / 2;
	kernel = Mat(kernel_size, kernel_size,CV_32FC1);

	float  segma_pow = 2 * sigma * sigma;   

	float  sum = 0;

	//  二元高斯函数
	for (size_t i = 0; i < kernel_size; i++)
	{
		for (size_t j= 0; j < kernel_size; j++)
		{
			float  temp = ((i - center) * (i - center) + (j - center) * (j - center) )/ segma_pow;
			kernel.at<float>(i, j) = 1 / (PI * segma_pow) * exp(-temp);
			sum += kernel.at<float>(i, j);
		}
	}


	// 归一化
	for (size_t i = 0; i < kernel_size; i++)
	{
		for (size_t j = 0; j < kernel_size; j++)
		{
			kernel.at<float>(i, j) = kernel.at<float>(i, j)/sum;
		}
	}

}

5*5 的高斯核，那个核数一般是不能超过11 ，超过11 其效果均值一样了

高斯滤波


//******************高斯滤波*************************
//第一个参数imageSource是待滤波原始图像；
//第二个参数imageGaussian是滤波后输出图像；
//第三个参数 kernel 是一个指向含有N个double类型数组；
//第四个参数size是滤波核的尺寸
//*************************************************************
void  GaussianFilter(const Mat& imageSource, Mat& imageGaussian, Mat& kernel, int size)
{
	if (!imageSource.data|| imageSource.channels()!=1)
	{
		return;
	}
	imageGaussian = Mat::zeros(imageSource.size(),CV_8UC1);
	
	float  gaussArray[100];
	// 将 kernel 的方阵 变成一个一维度数组 这样在循环的时候啊就少了一次内循环
	int m = 0;
	for (size_t i = 0; i < kernel.rows; i++)
	{
		for (size_t j = 0; j < kernel.cols; j++)
		{
			gaussArray[m] = kernel.at<float>(i,j);
			m++;
		}
	}

	//滤波
		for (int i = 0; i < imageSource.rows; i++)
		{
			for (int j = 0; j < imageSource.cols; j++)
			{
				int k = 0;
				for (int l = -size / 2; l <= size / 2; l++)
				{
					for (int g = -size / 2; g <= size / 2; g++)
					{
						//以下处理针对滤波后图像边界处理，为超出边界的值赋值为边界值
						int row = i + l;
						int col = j + g;
						row = row < 0 ? 0 : row;
						row = row >= imageSource.rows ? imageSource.rows - 1 : row;
						col = col < 0 ? 0 : col;
						col = col >= imageSource.cols ? imageSource.cols - 1 : col;
						//卷积和
						imageGaussian.at<uchar>(i, j) += gaussArray[k] * imageSource.at<uchar>(row, col);
						k++;
					}
				}
			}
		}


}




void  TestGaussian()
{
	Mat  kernel;
	CreateGaussianKernel(5, 1, kernel);

	 // 打印 高斯核
	for (int i = 0; i < kernel.rows; i++)
	{
		for (int j = 0; j < kernel.cols; j++)
		{
			cout << "    " << kernel.at<float>(i, j);
		}
		cout << endl;
	}

	Mat  src = imread("C:\\Users\\alber\\Desktop\\opencv_images\\529.jpg");
	Mat  dst, imageGaussian;
	ConvertRGB2GRAY(src, dst);
	 imwrite("C:\\Users\\alber\\Desktop\\opencv_images\\1\\1.jpg", dst);
	  GaussianFilter(dst, imageGaussian, kernel, 5);
	 imwrite("C:\\Users\\alber\\Desktop\\GaussianFilter.jpg", imageGaussian);
}

 

3、实现sobel 算子

推导出X Y方向的核 

【精选】Opencv 笔记5 边缘处理-canny、sobel、Laplacian、Prewitt_opencv 边缘处理_Σίσυφος1900的博客-CSDN博客

gradient =||dx||+||dy||

theta= atan(gradY / gradX) * 57.3  注意这里的角度转换


//******************Sobel算子计算X、Y方向梯度 以及  梯度方向角********************
//第一个参数imageSourc原始灰度图像；
//第二个参数imageSobelX是X方向梯度图像；
//第三个参数imageSobelY是Y方向梯度图像；
//第四个参数   theta  是梯度方向角数组指针  下一步很重要 就是要用这个值来计算
//*************************************************************
void  SobelGradDirction(const Mat imageSource, Mat& imageX, Mat& imageY, Mat& gradXY, Mat& theta)
{
	imageX = Mat::zeros(imageSource.size(), CV_32SC1);
	imageY = Mat::zeros(imageSource.size(), CV_32SC1);
	gradXY = Mat::zeros(imageSource.size(), CV_32SC1);
	theta = Mat::zeros(imageSource.size(), CV_32SC1);

	int rows = imageSource.rows;
	int cols = imageSource.cols;

	int stepXY = imageX.step;
	int step = imageSource.step;
	/*
	Mat.step参数指图像的一行实际占用的内存长度，
	因为opencv中的图像会对每行的长度自动补齐（8的倍数），
	编程时尽量使用指针，指针读写像素是速度最快的，使用at函数最慢。
	*/
	uchar* PX = imageX.data;
	uchar* PY = imageY.data;
	uchar* P = imageSource.data;
	uchar* XY = gradXY.data;

	for (int i = 1; i < rows - 1; i++)
	{
		for (int j = 1; j < cols - 1; j++)
		{
			int a00 = P[(i - 1) * step + j - 1];
			int a01 = P[(i - 1) * step + j];
			int a02 = P[(i - 1) * step + j + 1];

			int a10 = P[i * step + j - 1];
			int a11 = P[i * step + j];
			int a12 = P[i * step + j + 1];

			int a20 = P[(i + 1) * step + j - 1];
			int a21 = P[(i + 1) * step + j];
			int a22 = P[(i + 1) * step + j + 1];

			double gradY = double(a02 + 2 * a12 + a22 - a00 - 2 * a10 - a20);
			double gradX = double(a00 + 2 * a01 + a02 - a20 - 2 * a21 - a22);


			imageX.at<int>(i, j) = abs(gradX);
			imageY.at<int>(i, j) = abs(gradY);
			if (gradX == 0)
			{
				gradX = 0.000000000001;
			}
			theta.at<int>(i, j) = atan(gradY / gradX) * 57.3;
			theta.at<int>(i, j) = (theta.at<int>(i, j) + 360) % 360;
			gradXY.at<int>(i, j) = sqrt(gradX * gradX + gradY * gradY);
			//XY[i*stepXY + j*(stepXY / step)] = sqrt(gradX*gradX + gradY*gradY);
		}

	}
	convertScaleAbs(imageX, imageX);
	convertScaleAbs(imageY, imageY);
	convertScaleAbs(gradXY, gradXY);
}

 

 这个不明显，所以我打算换个图像test

4、局部非极大值抑制

这里我们就要用到上面一步在sobel里面计算求得的x y 方向以及梯度方向的那些 东西了。

原理：

拿到当前点的梯度方向[0,360]，判断其在那个区域,计算梯度方向（一个方向，两个值）在不同权重下（w=dy/dx）的灰度值t1 t2， 最后判断当前点灰度值current 和t1 t2的大小比较，如果当前值current小于t1 t2中的任何一个那么，当前的点就不会是边缘的候选点，current=0；

下面我们看一下梯度的分布：

[0-45] U[180-225]

 [45-90] U[225-270]

 [90-135] U[270-315]

 [135-180] U[315-360]

code:

/// <summary>
///  局部极大值抑制 ，计算八领域  沿着该点梯度方向，比较前后两个点的幅值大小，若该点大于前后两点，则保留，若该点小于前后两点任意一点，则置为0；
/// </summary>
/// <param name="imageInput"> 输入的图像</param>
/// <param name="imageOutput"></param>
/// <param name="theta"></param>
/// <param name="imageX"> </param>
/// <param name="imageY"></param>
void NonLocalMaxValue(const Mat imageInput, Mat& imageOutput, const Mat& theta, const Mat& imageX, const Mat& imageY)
{
	if (!imageInput.data || imageInput.channels() != 1)
	{
		return;
	}
	imageOutput = imageInput.clone();
	int  rows = imageOutput.rows;
	int  cols = imageOutput.cols;

	int  g00, g01, g02, g10, g11, g12, g20, g21, g22;
	int  g1, g2, g3, g4;
	for (size_t i = 1; i < rows-1; i++)
	{
		for (size_t j = 1; j < cols-1; j++)
		{
			// 第一行
			g00 = imageOutput.at<uchar>(i - 1, j - 1);
			g01 = imageOutput.at<uchar>(i - 1, j);
			g02 = imageOutput.at<uchar>(i - 1, j+1);

			// 第二行
			g10 = imageOutput.at<uchar>(i , j - 1);
			g11 = imageOutput.at<uchar>(i , j);
			g12 = imageOutput.at<uchar>(i, j + 1);

			// 第三行
			g20 = imageOutput.at<uchar>(i+1, j - 1);
			g21 = imageOutput.at<uchar>(i+1, j);
			g22 = imageOutput.at<uchar>(i+1, j + 1);
			// 当前点的梯度方向 
			int  direction = theta.at<int>(i, j);

			g1 = 0; 
			g2 = 0;
			g3 = 0;
			g4 = 0;

			// 保存亚像素点插值得到的灰度值 
			double  t1 = 0;
			double  t2 = 0;


			// 计算权重 
			double  w = fabs((double)imageY.at<uchar>(i,j)  / (double)imageX.at<uchar>(i, j));
			if (w==0)
			{
				w = 0.0000001;
			}
			if (w>1)
			{
				w = 1 / w;
			}

			//  g00     g01   g02
			//  g10     g11   g12
			//  g20     g21   g22
			// ================================
			if ((0 <= direction && direction < 45) || 180 <= direction && direction < 225)
			{
				t1 = g10 * (1 - w) + g20 * (w);
				t2 = g02 * (w)+g12 * (1 - w);
			}

			if ((45 <= direction && direction < 90) || 225 <= direction && direction < 270)
			{
				t1  = g01 * (1 - w) + g02 * (w);
				t2  = g20 * (w)+g21 * (1 - w);
			}

			if ((90 <= direction && direction < 135) || 270 <= direction && direction < 315)
			{
				t1  = g00 * (w)+g01 * (1 - w);
				t2  = g21 * (1 - w) + g22 * (w);
			}

			if ((135 <= direction && direction < 180) || 315 <= direction && direction < 360)
			{
				t1  = g00 * (w)+g10 * (1 - w);
				t2  = g12 * (1 - w) + g22 * (w);
			}
		
			if (imageInput.at<uchar>(i,j)<t1 || imageInput.at<uchar>(i, j) < t2)
			{
				imageOutput.at<uchar>(i, j) = 0;
			}
		}
	}

}

5、 双阈值连接处理

双阈值处理

给定一个高阈值high   一个低阈值low, low*[1.5,2]=high 这个是给定规则

判断条件就是

                      当前current<low  ，那么current=0

                       low<current<hight  current 不处理 

                       current>hight   current=255

/// <summary>
///     双阈值原理：   
///   制定一个低阈值 L  一个 高阈值 H，一般取H为整体图像灰度分布的 7成 并且H为1.5-2L
///  灰度值<L   gray=0, gray>H gray=255;
/// </summary>
/// <param name="imageIn"></param>
/// <param name="low"></param>
/// <param name="hight"></param>
void DoubleThreshold(Mat& imageIn, const double low, const double hight)
{
	if (!imageIn.data || imageIn.channels() != 1)
	{
		return;
	}
	int  rows = imageIn.rows;
	int  cols = imageIn.cols;
	
	double  gray;
	for (size_t i = 0; i < rows ; i++)
	{
		for (size_t j = 0; j < cols ; j++)
		{
			gray = imageIn.at<uchar>(i, j);
			gray = gray > hight ? (255) : (gray < low) ? (0) : gray;
			imageIn.at<uchar>(i, j) = gray;
		}
	}
}

 

 将边缘链接起来

经过上每一步的双阈值处理，我们基本上已经拿到了边缘点的候选点，下一步就是将这些边缘点联合起来，组成一个边缘轮廓

这里我们再次使用双阈值的机制  low  和 hight   和当前点的灰度值current 

规则如下： current  的8邻域的灰度值 M介于【low，hight】中，有，可能是边缘点，这个领域的点M=255 ，并且回退 ， 如果领域类没有 说明这个点是一个孤立的点 不做处理，

最后判断图像中所有的点，不是255 就是0 ，生成边缘

void DoubleThresholdLink(Mat& imageInput, double lowTh, double highTh)
{
	if (!imageInput.data || imageInput.channels() != 1)
	{
		return;
	}
	int  rows = imageInput.rows;
	int  cols = imageInput.cols;
	double  gray;

	for (size_t i = 1; i < rows-1; i++)
	{
		for (size_t j = 1; j < cols-1; j++)
		{
			gray = imageInput.at<uchar>(i, j);
			if (gray==255)
			{
				continue;
			}
			bool reback = false;
			 // 寻找8领域中是否有介于low 和hight 的值 
			for (size_t k = -1; k < 2; k++)
			{
				for (size_t  l= -1; l < 2; l++)
				{
					if (k == 0 && l == 0)  //当前点 
					{
						continue;
					}
					double t = imageInput.at<uchar>(i + k, j + l);
					if (t>= lowTh&& t<highTh)
					{
						imageInput.at<uchar>(i + k, j + l) = 255;
						reback = true;
					}
				}
			}
			// 回退 
			if (reback)
			{
				if (i > 1) i--;
				if (j > 2)j -= 2;
			}
		}
	}

	 //  最后调整 
	for (int i = 0; i < rows; i++)
	{
		for (int j = 0; j < cols; j++)
		{
			if (imageInput.at<uchar>(i, j) != 255)
			{
				imageInput.at<uchar>(i, j) = 0;
			}
		}
	}

}

opencv 库结果：

还是用opencv库吧，结果比这个好多了 

三、halcon 效果对比

halcon的效果更好

code

read_image (Grayimage, 'C:/Users/alber/Desktop/opencv_images/1/grayImage.jpg')
edges_sub_pix (Grayimage, Edges, 'canny', 1, 20, 40)


 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1156168.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

C语言KR圣经笔记 2.11条件表达式 2.12优先级和求值顺序

C语言KR圣经笔记 2.11条件表达式 2.12优先级和求值顺序

2.11条件表达式 if (a > b) z a; else z b; 上面的语句计算 a 和 b 中的最大值并存入 z。而使用三元操作符 ? : 的条件表达式&#xff0c;为这个结构及类似结构提供了另一种写法。在如下表达式 expr1 ? expr2 : expr3 中&#xff0c;首先对 expr1 求值。如果值非0 …
阅读更多...
0基础学习PyFlink——个数滚动窗口(Tumbling Count Windows)

0基础学习PyFlink——个数滚动窗口(Tumbling Count Windows)

大纲 Tumbling Count WindowsmapreduceWindow Size为2Window Size为3Window Size为4Window Size为5Window Size为6 完整代码参考资料 之前的案例中&#xff0c;我们的Source都是确定内容的数据。而Flink是可以处理流式&#xff08;Streaming&#xff09;数据的&#xff0c;就是…
阅读更多...
go中url.ParseRequestURI和url.Parse函数的踩坑记

go中url.ParseRequestURI和url.Parse函数的踩坑记

使用url.Parse函数 package mainimport ("fmt""net/url" )func main() {attrRawUrl : "http://localhost?wifitrue&carrier#Staysafe AIS&osandroid"urlObj, _ : url.Parse(attrRawUrl)fmt.Printf("urlObj:%#v\n", *urlObj)…
阅读更多...
python 安装 pyquicklz 库函数

python 安装 pyquicklz 库函数

问题描述&#xff1a; 安装 pyquicklz 库的时候 报错 error: subprocess-exited-with-error 解决方法&#xff1a; 安装 Cython 库&#xff1a; pip install Cython -i https://pypi.tuna.tsinghua.edu.cn/simple/ 安装 Microsoft C Build Tools Microsoft C Build Tools 的下…
阅读更多...
Spring MVC 续

Spring MVC 续

一、拦截器 1.介绍拦截器 1.拦截器&#xff08;springmvc提供&#xff09; 2.只拦截控制单元&#xff08;生效必须配置拦截器&#xff09; 3.会拦截静态资源&#xff0c;使用拦截器时&#xff0c;尽量使用局部配置&#xff0c;配置拦截的控制单元即可。 注意&#xff1a;只…
阅读更多...
python多环境并存

python多环境并存

1. 现况简介 1.1 本人windows所存Python版本 Python 2.7 Python 3.6 Python 3.7 1.2 Python 各版本路径如下 Python 2.7Python 3.6Python 3.7C:\Server\Python27C:\Server\Python36C:\Server\Python37 1.3 系统环境变量配置如下 2. 解决方案 2.1 进入目录 cd C:\Server…
阅读更多...
【机器学习】三、特征选择与稀疏学习

【机器学习】三、特征选择与稀疏学习

特征选择和稀疏学习 子集搜索与评价 对象都有很多属性来描述&#xff0c;属性也称为特征&#xff08;feature&#xff09;&#xff0c;用于刻画对象的某一个特性。对一个学习任务而言&#xff0c;有些属性是关键有用的&#xff0c;而有些属性则可能不必要纳入训练数据。对当前学…
阅读更多...
win10 下编译ffmpeg3.36.tar.gz

win10 下编译ffmpeg3.36.tar.gz

所需工具&#xff1a; win10 ffmpeg3.36.tar.gz。 或其他版本&#xff0c;下载地址&#xff1a;Index of /releases msys2。 下载地址&#xff1a;http://www.msys2.org。 Visual Studio 2017。 1. 安装MSYS MSYS2像是windows下的一个子系统&#xff0c;…
阅读更多...
Day16力扣打卡

Day16力扣打卡

打卡记录
阅读更多...
`.NET Web`新人入门必学项目`EarthChat`

`.NET Web`新人入门必学项目`EarthChat`

.NET Web新人入门必学项目EarthChat EarthChat是一个基于.NET 7的实战项目&#xff0c;EarthChat提供了很多的最佳实践&#xff0c;EarthChat的目标也是成为一个很多人都喜欢的大型聊天业务系统&#xff0c;并且将结合SKAI大模型进行打造智能业务系统&#xff0c;在EarthChat中…
阅读更多...
05_es分布式搜索引擎1

05_es分布式搜索引擎1

一、初始elasticsearch 1.elasticsearch简单介绍 ①什么是elasticsearch&#xff1f; 开源的分布式搜索引擎&#xff0c;实现海量数据搜索&#xff0c;日志统计&#xff0c;分析&#xff0c;系统监控等功能 ②什么是elastic stack&#xff1f; 是以elasticsearch为核心的技…
阅读更多...
【COMP304 LEC4 LEC5】

【COMP304 LEC4 LEC5】

LEC 4 1. Truth-Functionality Propositional logic 的connectives&#xff08;连接词&#xff09;are truth-functional 但是&#xff0c;有时候的描述不是true-functional的&#xff0c;比如&#xff1a;"Knowing that", "It is necessary that",&quo…
阅读更多...
微信小程序开发-微信支付退款功能【附有完整代码】

微信小程序开发-微信支付退款功能【附有完整代码】

之前有写过详细的微信支付功能&#xff1a;微信支付 我们使用weixin-java-pay的jar包等&#xff0c;配置上的流程同微信支付&#xff0c;可以看上面的文章。 退款使用的WxPayService类的refundV3方法。使用该方法需要在微信支付配置的基础上加上&#xff1a;apiclient_key.pem…
阅读更多...
Linux期末复习——多线程编程

Linux期末复习——多线程编程

线程概述 线程基本编程 函数说明 pthread_create(): 创建线程&#xff0c;成功返回0pthread_exit(): 主动退出线程&#xff0c;成功返回0pthread_join(): 挂起线程等待结束&#xff0c;成功返回0pthread_cancel在别的线程中终止另一个线程的执行&#xff0c;成功返回0 示例…
阅读更多...
sql文件批处理程序-java桌面应用

sql文件批处理程序-java桌面应用

项目效果&#xff1a; 支持sql文件夹批处理&#xff0c;选中文件夹或者sql文件 支持测试连接&#xff0c;可以校验数据库配置 支持报错回显&#xff0c;弹出报错文件名以及问题语句 支持在程序中修改错误语句&#xff0c;用户可以选择保存修改内容继续执行或不保存修改只执行…
阅读更多...
线性代数 第四章 线性方程组

线性代数 第四章 线性方程组

一、矩阵形式 经过初等行变换化为阶梯形矩阵。当&#xff0c;有解&#xff1b;当&#xff0c;有非零解。 有解&#xff0c;等价于 可由线性表示 克拉默法则&#xff1a;非齐次线性方程组中&#xff0c;系数行列式&#xff0c;则方程组有唯一解&#xff0c;且唯一解为 其中是…
阅读更多...
TestCenter测试管理工具

TestCenter测试管理工具

estCenter&#xff08;简称TC&#xff09;一款广受好评的测试管理工具&#xff0c;让测试工作更规范、更有效率&#xff0c;实现测试流程无纸化&#xff0c;测试数据资产化。 产品概述 TC流程图 产品功能 一、案例库 案例库集中化管理&#xff0c;支持对测试用例集中管理&…
阅读更多...
Gartner报告 | Mendix再次成为低代码领导者！Mendix在愿景完整性和执行能力领域的排名最为靠前。

Gartner报告 | Mendix再次成为低代码领导者！Mendix在愿景完整性和执行能力领域的排名最为靠前。

本文作者: Hans de Visser, Mendix 首席产品官 在最新发布的2023 Gartner魔力象限图™ 中对于企业级低代码应用程序平台&#xff0c;Gartner指出&#xff0c;企业IT领导者需要满足“应用程序开发向更高抽象级别迈进的步伐&#xff0c;并采用低代码平台来加速应用程序开发。” 此…
阅读更多...
【华为】路由器以PPPoE拨号接入广域网

【华为】路由器以PPPoE拨号接入广域网

组网需求 用户希望以PPPoE拨号方式接入广域网&#xff0c;如图1所示&#xff0c;Router作为PPPoE客户端&#xff0c;得到PPPoE服务器的认证后获得IP地址&#xff0c;实现用户接入互联网的需求。内网网关地址&#xff08;即VLANIF1接口的IP地址&#xff09;为10.137.32.1/24。 …
阅读更多...
N-131基于jsp,ssm物流快递管理系统

N-131基于jsp,ssm物流快递管理系统

开发工具&#xff1a;eclipse&#xff0c;jdk1.8 服务器&#xff1a;tomcat7.0 数据库&#xff1a;mysql5.7 技术&#xff1a; springspringMVCmybaitsEasyUI 项目包括用户前台和管理后台两部分&#xff0c;功能介绍如下&#xff1a; 一、用户(前台)功能&#xff1a; 用…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023