Canny算子c++

OStack程序员社区-中国程序员成长平台 › 门户 › 编程› C++›C++教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

、功能简介及其运行

（一）、功能：该程序实现了canny算子求图片的边缘，其中主要包括七大部分：

1、对传入的彩色图片二值化

2、对二值化后的图片进行高斯滤波

3、使用sobel算子对滤波之后的图形分别求x，y方向上的梯度

4、计算出梯度幅值

5、对梯度图像做非极大抑制

6、对非极大抑制后的图像做双阈值处理

7、对双阈值处理后的图像进行连接操作（处理阈值中间的点）

（二）、运行：注意要在release文件夹下运行exe

运行程序后终端会显示所用到的sobel算子矩阵和高斯滤波矩阵，同时会弹出多张图片，他包括：

1、原图片：Lena.jpg

2、二值化后的图片:gray.jpg

3、高斯滤波后的图片:guss,jpg

4、x，y方向梯度的图片:gradit_x.jpg gradint_y.jpg

5、梯度图片:gradint.jpg

6、非极大抑制后的图片:afterNms.jpg

7、双阈值后的图片:afterDT.jpg

8、连接操作后的图片（即最终的canny算法图片）canny.jpg

9、使用opencv自带函数得到的canny算子图片（用于对比）

弹出的同时，会将这些图片保存在当前路径的文件下,命名为上面的命名。

二、开发环境

操作系统：windows

Opencv版本：2.4

编译器：vs2015

语言：c++

请助教运行release下的exe。

三、程序思路

大体思路其实与上面七大部分相同，这里做一个概述，并说明大体实现，具体通过这个简单流程图来说明（流程图viso文件附在压缩包内））

一、具体实现

（1）图像灰度化：

图像灰度画函数：Mat getGray(Mat &image)

作用：返回一张彩色图片的灰度图片

实现方式：才用标准的转化公式：Gray = R*0.299 + G*0.587 + B*0.114

循环的取出每一个像素，对每一个彩色像素做该运算就可得到灰度图片。

（2）获取高斯核

图像灰度画函数：double **getGussKernel(int size, double sigma)

作用：返回一个二维double类型指针，里面是对应size和sigma的高斯卷积核

实现方式：通过查阅资料和博客我们知道高斯卷积核公式：

由这个公式，我们可以容易写出一下核心代码：

最后记得要做归一化，之后返回指针g即可。

（3）卷积函数的两种实现

现在我们得到了一个高斯核，要做卷积了，由于我们知道在求梯度图片的时候同样要用到卷积，所以我们写一个卷积函数。

卷积函数：Mat Convolution1(Mat &image, double **kernel,int size)

Mat Convolution2(Mat &image, double **kernel,int size)

参数：带卷积图像卷积核卷积核大小

这两种方法大体上相同，就是在对边缘的处理上一个视边缘的无效邻域视为边缘本身；一个视为0，根据实验效果来看，两者没有太大差别（边缘本身就看不出来）

作用：将图像与卷积核做卷积处理并返回卷积后的图像（不改变原图）

具体实现：采用循环的方式，对每一个像素都对他的八邻域做分别做乘积后相加。需要注意的是不同的边缘控制代码有一些不同。

(需要注意的是，为了方便计算，我们事先把卷积核转化为1维，这样省了不少事，这个主要感谢http://blog.csdn.net/dcrmg/article/details/52344902这篇博客上的灵感，不然处理起来有点混乱。)

最后返回Mat 图像就是卷积之后的图像。

有了这个工具，我们只需要使用这个工具与步骤而获得的高斯核卷积就可以得到高斯滤波后的图像。

（4）获得梯度图像

这里分三步：

（1）获得x方向的梯度图像

方法：使用sobel算子：

sobel_x[3][3] = { { -1,-2,-1 } ,{ 0,0,0 } ,{ 1,2,1 } };

与我们之前写好的卷积函数做卷积即可。

（2）获得y方向上的梯度图像

方法：使用sobel算子：

sobel_y[3][3] = { { -1,0,1 } ,{ -2,0,2 } ,{ -1,0,1 } };

与我们之前写好的卷积函数做卷积即可。

（3）获得综合梯度的幅值

Sobel函数：

Mat Sobel(Mat &image_x,Mat &image_y)

参数：x方向梯度图像 y方向梯度图像

作用：返回梯度图像

具体实现：根据公式

可以知道新图片的每一像素点都等于x，y梯度方向上的欧氏距离，由此思路可以清晰的写出代码：

最后返回Mat图像即可

（5）非极大抑制

非极大值抑制就是要消除梯度方向上非极大值的点，避免边缘非常“厚”的问题，是canny算法的精髓之一。

Nms函数：

Mat Nms(Mat &image, Mat &image_x, Mat &image_y)

参数：梯度图像 x方向梯度图像 y方向梯度图像

作用：通过计算梯度方向和插值对图像进行非极大抑制

具体实现:我们知道非极大抑制的难点就在于找和当前点梯度方向相同的相邻点，由于很有可能该点处于两个像素的中间，即实际该点没有像素值，但是梯度方向指向该值，所以我们在这里使用插值的方法。通俗的解释就是

假设这里我们以c点为中心，那么c点的梯度方向的邻域点可能落在上图中四个小正方体的外接边上的八个边上，而我们只知道八个顶点的信息，为了取得亚像素的信息，我们采用线性插值的方法，插值点有四种位置，我们需要根据梯度方向的不同来确定具体的位置。根据线性插值的一般公式：

M(dtmp1)=w*M(g2)+(1-w)*M(g1)

其中w=|x方向梯度|/|y方向梯度|（靠x方向时）

或w=|y方向梯度|/|x方向梯度|（靠y方向时）

基于这种考虑，我们通过判断x与y的绝对值大小来判断c2与c4的位置

通过比较x与y是否同号来确定c1，c3的位置。

其他方向同理

在找到其梯度方向上的插值点之后，剩下的就是要与这两个插值点进行比较，若当前点比他们都大，说明当前点为极大值点，保留。否则就置成0。代码实现较简单使用简单的判断即可。（这里没有使用梯度角，而是直接用了x，y方向上的梯度图像来比较主要是为了理解方便，而且梯度角非常容易出错）

（6）双阈值

到上一步，我们得到了大致的边缘图片，但是这幅图片边缘处太密，我们想通过双阈值的方法来处理图片，突出灰度值较大的边缘部分，将灰度值较小的部分置为0.

双阈值函数：

Mat DoubleThreshold(Mat &image, double high_threshold, double low_threshold)

参数： Nms后的图像高阈值低阈值

作用：输出对应双阈值之后的图像（没有对中间阈值部分进行连接）

连接函数：

Mat Link1(Mat &image)

作用：对执行完DoubleThreshold函数的图像的中间部分做中间的连接处理，返回最终的边缘函数。

具体实现：实现分两步。

首先第一步很简单，就是遍历图像的每一个像素，并对他的值进行判断，若该值小于低阈值就为0；若高于高阈值就置为255。对于中间的点先不理他，在后面做连接的时候再处理。

第二步连接：在这里实现了两种连接。后面在实验结果分析会比较哪种比较好。第一种连接方式的原则很简单：

遍历一个经过DoubleThreshold后的图像，对于每一个点再去遍历他的八连通邻域，若其八连通邻域全是0，说明这是一个孤立的边缘点，可以将其去掉；若其八邻域内有非0的点，不管是255还是处于中间的点，则说明这个点可以作为边缘连接点，就将其置为255。这样循环遍历，然后返回。

核心程序截图如下：

第二种才用递归的方式，称其为Link2。

递归的主要特点使每次从当前刚刚变为边缘的图像开始深度优先搜索，这样有不会出现“误伤”的情况。具体实现分为递归函数和主控函数，核心递归函数如图所示：

最终canny为

opencv自带的为

最后附上源代码：

//#include <stdafx.h>  
#include "cv.h"  
#include "cxcore.h"  
#include "highgui.h"  
#include<cstring>
#include<math.h>
#include<iostream>
#define PI 3.1415926
using namespace cv;
using namespace std;
char path[20];
double sobel_y[3][3] = { { -1,0,1 }   ,{ -2,0,2 }    ,{ -1,0,1 } };//sobel算子
double sobel_x[3][3] = { { -1,-2,-1 }    ,{ 0,0,0 }    ,{ 1,2,1 } };
int xNum[8] = { 1,1,0,-1,-1,-1,0,1 };
int yNum[8] = { 0,1,1,1,0,-1,-1,-1 };//方向
/*返回该函数的灰度值*/
Mat getGray(Mat &image)
{
    if (!image.data || image.channels() != 3)
    {
        printf("图片属性错误");
        return image;
    }
    Mat gray_image = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    //Mat gray_image(2, image.size, CV_8UC1, Scalar::all(0));
    int image_step = image.step;
    for (int i = 0; i < gray_image.rows; i++)
    {
        for (int j = 0; j < gray_image.cols; j++)
        {
            int base = image_step*i;//基地址
            gray_image.data[i*gray_image.step + j] = 0.114*image.data[base + j * 3 + 0] \
                + 0.587*image.data[base + j * 3 + 1] + 0.299*image.data[base + j * 3 + 2];
        }
    }
    return gray_image;
}
/*获取尺寸为size 标准差为sigma的高斯核*/

double **getGussKernel(int size, double sigma)
{
    double temp = 1 / (2 * PI*sigma*sigma);
    int x0 = size / 2;
    int y0 = size / 2;
    double sum = 0;//归一化做准备
    double **g = new double *[size];
    for (int i =0; i < size; i++)
    {
        g[i] = new double[size];
    }
    for (int x = 0; x < size; x++)
    {
        for (int y = 0; y < size; y++)
        {
            g[x][y] = temp*exp(-((x - x0)*(x - x0) + (y - y0)*(y - y0)) / (2 * sigma*sigma));
            sum += g[x][y];
        }
    }
    for (int x = 0; x < size; x++)
    {
        for (int y = 0; y < size; y++)
        {
            g[x][y] = g[x][y] / sum;
            cout << g[x][y] << "  ";
        }
        cout << endl << endl;
    }
    return g;
}
/*对图片做kernel卷积 边缘处理方案一*/
Mat Convolution1(Mat &image, double **kernel,int size)
{
    Mat after_convolution = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    int count = 0;
    double kernel_temp[100];
    for (int i = 0; i<size*size; i++)
    {
        kernel_temp[i] = 0;  //赋初值，空间分配  
    }
    for (int i = 0; i < size; i++)//将核转化为一维，方便卷积***
    {
        for (int j = 0; j < size; j++)
        {
            kernel_temp[count] = kernel [i][j];
            count++;
        }
    }
    /*边缘处理才用边缘的点代替值*/
    for (int i = 0; i < image.rows; i++)
    {
        for (int j = 0; j < image.cols; j++)
        {
            int k = 0;//卷积核的索引
            for (int x = -size / 2; x <=size / 2; x++)
            {
                for (int y = -size / 2; y <= size / 2; y++)
                {
                    int r = i + x;
                    int c = j + y;
                    r = r < 0 ? 0 : r;//处理顶部边缘
                    r = r >= image.rows ? image.rows - 1 : r;//处理底部边缘
                    c = c < 0 ? 0 : c;
                    c = c >= image.cols ? image.cols - 1 : c;
                    after_convolution.at<uchar>(i, j) += kernel_temp[k] * image.at<uchar>(r, c);
                    k++;
                }
            }
        }
    }
    return after_convolution;
}
Mat Convolution2(Mat &image, double **kernel, int size)
{
    Mat after_convolution = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    int count = 0;
    double kernel_temp[100];
    for (int i = 0; i<size*size; i++)
    {
        kernel_temp[i] = 0;  //赋初值，空间分配  
    }
    for (int i = 0; i < size; i++)//将核转化为一维，方便卷积***
    {
        for (int j = 0; j < size; j++)
        {
            kernel_temp[count] = kernel[i][j];
            count++;
        }
    }
    /*边缘处理用0代替*/
    for (int i = 0; i < image.rows; i++)
    {
        for (int j = 0; j < image.cols; j++)
        {
            int k = 0;//卷积核的索引
            for (int x = -size / 2; x <= size / 2; x++)
            {
                for (int y = -size / 2; y <= size / 2; y++)
                {
                    int r = i + x;
                    int c = j + y;
                    r = r < 0 ? -1 : r;//处理顶部边缘
                    r = r >= image.rows ? - 1 : r;//处理底部边缘
                    c = c < 0 ? -1: c;
                    c = c >= image.cols ? -1 : c;
                    if (r == -1 || c == -1)
                        after_convolution.at<uchar>(i, j) += kernel_temp[k] * 0;
                    else
                        after_convolution.at<uchar>(i, j) += kernel_temp[k] * image.at<uchar>(r, c);
                    k++;
                }
            }
        }
    }
    return after_convolution;
}
//卷积公式加绝对值
Mat Convolution3(Mat &image, double (*kernel)[3], int size)
{
    double sum=0;
    Mat after_convolution = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    int count = 0;
    double kernel_temp[100];
    for (int i = 0; i<size*size; i++)
    {
        kernel_temp[i] = 0;  //赋初值，空间分配  
    }
    for (int i = 0; i < size; i++)//将核转化为一维，方便卷积***
    {
        for (int j = 0; j < size; j++)
        {
            kernel_temp[count] = kernel[i][j];
            count++;
            printf("%f  ", kernel[i][j]);
        }
        printf("\n\n");
    }
    /*边缘处理才用边缘的点代替值*/
    for (int i = 0; i < image.rows; i++)
    {
        for (int j = 0; j < image.cols; j++)
        {
            sum = after_convolution.at<uchar>(i, j);
            int k = 0;//卷积核的索引
            for (int x = -size / 2; x <= size / 2; x++)
            {
                for (int y = -size / 2; y <= size / 2; y++)
                {
                    int r = i + x;
                    int c = j + y;
                    r = r < 0 ? 0 : r;//处理顶部边缘
                    r = r >= image.rows ? image.rows - 1 : r;//处理底部边缘
                    c = c < 0 ? 0 : c;
                    c = c >= image.cols ? image.cols - 1 : c;
                    sum += (kernel_temp[k] * image.at<uchar>(r, c));
                    k++;
                }
            }
            after_convolution.at<uchar>(i, j) = abs(sum);
        }
    }
    convertScaleAbs(after_convolution, after_convolution);
    return after_convolution;
}
Mat Sobel(Mat &image_x,Mat &image_y, double *gradint_angle)
{
    Mat after_sobel = Mat::zeros(image_x.size(), CV_32FC1);//创建一幅空图片注意图片类型
    int k = 0;
    for (int i = 0; i < after_sobel.rows; i++)
    {
        for (int j = 0; j < after_sobel.cols; j++)
        {
            double x = image_x.at<uchar>(i, j);
            double y = image_y.at<uchar>(i, j);
            after_sobel.at<float>(i, j) = sqrt(x*x + y*y);
        }
    }
    convertScaleAbs(after_sobel, after_sobel);//转为8位无符号整形
    return after_sobel;
}

Mat Nms1(Mat &image, Mat &image_x, Mat &image_y)
{
    Mat after_nms = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    after_nms = image.clone();
    double center, temp1, temp2;
    int c1, c2, c3, c4;
    double x, y;//图片在x，y方向的梯度
    double k;
    for (int i = 1; i < image.rows-1; i++)
    {
        for (int j = 1; j < image.cols-1; j++)
        {
            center = image.at<uchar>(i, j);
            x = image_x.at<uchar>(i, j);
            y = image_y.at<uchar>(i, j);
            if (abs(y) > abs(x))//确定c2c4位置 考y轴
            {
                c2 = image.at<uchar>(i - 1, j);//上
                c4 = image.at<uchar>(i - 1, j);
                if (y == 0)
                    k = 0;
                else
                {
                    k = fabs(x) /fabs(y);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j + 1);
                    c3 = image.at<uchar>(i + 1, j - 1);
                }
                else//否则24象限
                {
                    c3 = image.at<uchar>(i + 1, j + 1);
                    c1 = image.at<uchar>(i - 1, j - 1);
                }
            }
            else
            {
                c2 = image.at<uchar>(i , j+1);//上
                c4 = image.at<uchar>(i - 1, j-1);
                if (x == 0)
                    k = 0;
                else
                {
                    k = fabs(y) / fabs(x);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j - 1);
                    c3 = image.at<uchar>(i + 1, j + 1);
                }
                else//否则1,3象限
                {
                    c1 = image.at<uchar>(i + 1, j - 1);
                    c3 = image.at<uchar>(i - 1, j + 1);
                }
            }
            temp1 = k*c1 + (1 - k)*c2;
            temp2 = k*c3 + (1 - k)*c4;

            if (center >= temp1&&center >= temp2)
            {
                //是极大值
                ;
            }
            else
            {
                //不是最大值置0
                after_nms.at<uchar>(i, j) = 0;
            }
        }
    }
    return after_nms;
}
Mat Nms2(Mat &image, Mat &image_x, Mat &image_y)
{
    Mat after_nms = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    after_nms = image.clone();
    double center, temp1, temp2;
    int c1, c2, c3, c4;
    double x, y;//图片在x，y方向的梯度
    double k;
    for (int i = 1; i < image.rows - 1; i++)
    {
        for (int j = 1; j < image.cols - 1; j++)
        {
            center = image.at<uchar>(i, j);
            x = image_x.at<uchar>(i, j);
            y = image_y.at<uchar>(i, j);
            if (abs(y) > abs(x))//确定c2c4位置 考y轴
            {
                c2 = image.at<uchar>(i, j + 1);//上
                c4 = image.at<uchar>(i, j - 1);
                if (y == 0)
                    k = 0;
                else
                {
                    k = fabs(x) / fabs(y);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j + 1);
                    c3 = image.at<uchar>(i + 1, j - 1);
                }
                else//否则24象限
                {
                    c3 = image.at<uchar>(i + 1, j + 1);
                    c1 = image.at<uchar>(i - 1, j - 1);
                }
            }
            else
            {
                c2 = image.at<uchar>(i - 1, j);//上
                c4 = image.at<uchar>(i + 1, j);
                if (x == 0)
                    k = 0;
                else
                {
                    k = fabs(y) / fabs(x);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j - 1);
                    c3 = image.at<uchar>(i + 1, j + 1);
                }
                else//否则1,3象限
                {
                    c1 = image.at<uchar>(i + 1, j - 1);
                    c3 = image.at<uchar>(i - 1, j + 1);
                }
            }
            temp1 = k*c1 + (1 - k)*c2;
            temp2 = k*c3 + (1 - k)*c4;

            if (center >= temp1&&center >= temp2)
            {
                //是极大值
                ;
            }
            else
            {
                //不是最大值置0
                after_nms.at<uchar>(i, j) = 0;
            }
        }
    }
    return after_nms;
}
Mat Nms3(Mat &image, Mat &image_x, Mat &image_y)
{
    Mat after_nms = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    after_nms = image.clone();
    double center, temp1, temp2;
    int c1, c2, c3, c4;
    double x, y;//图片在x，y方向的梯度
    double k;
    for (int i = 1; i < image.rows - 1; i++)
    {
        for (int j = 1; j < image.cols - 1; j++)
        {
            center = image.at<uchar>(i, j);
            x = image_x.at<uchar>(i, j);
            y = image_y.at<uchar>(i, j);
            if (abs(y) < abs(x))//确定c2c4位置 考y轴
            {
                c2 = image.at<uchar>(i, j + 1);//上
                c4 = image.at<uchar>(i, j - 1);
                if (y == 0)
                    k = 0;
                else
                {
                    k = fabs(y) / fabs(x);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j + 1);
                    c3 = image.at<uchar>(i + 1, j - 1);
                }
                else//否则24象限
                {
                    c3 = image.at<uchar>(i - 1, j - 1);
                    c1 = image.at<uchar>(i + 1, j + 1);
                }
            }
            else
            {
                c2 = image.at<uchar>(i - 1, j);//上
                c4 = image.at<uchar>(i + 1, j);
                if (x == 0)
                    k = 0;
                else
                {
                    k = fabs(x) / fabs(y);//比例
                }
                if (x*y < 0)//两方向不相同，13象限
                {
                    c1 = image.at<uchar>(i - 1, j - 1);
                    c3 = image.at<uchar>(i + 1, j + 1);
                }
                else//否则1,3象限
                {
                    c1 = image.at<uchar>(i - 1, j + 1);
                    c3 = image.at<uchar>(i + 1, j - 1);
                }
            }
            temp1 = k*c1 + (1 - k)*c2;
            temp2 = k*c3 + (1 - k)*c4;

            if (center >= temp1&&center >= temp2)
            {
                //是极大值
                ;
            }
            else
            {
                //不是最大值置0
                after_nms.at<uchar>(i, j) = 0;
            }
        }
    }
    return after_nms;
}


Mat DoubleThreshold(Mat &image, double high_threshold, double low_threshold)
{
    Mat after_threshold = Mat::zeros(image.size(), CV_8UC1);//创建一幅空图片
    after_threshold = image.c

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

C++编译错误"astorageclasscanonlybespecifiedforobjectsandfunctions"解决 ...发布时间：2022-07-13

DES加密解密算法C++实现发布时间：2022-07-13

剪的笔顺,诠释剪的笔画,认识剪的部首

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期

阅读：19240|2023-10-27

2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知

阅读：10001|2022-11-06

3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道

阅读：8331|2022-11-06

4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要

阅读：8701|2022-11-06

5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多

阅读：8647|2022-11-06

6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不

阅读：9672|2022-11-06

7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很

阅读：8632|2022-11-06

8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法

阅读：8005|2022-11-06

9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win

阅读：8668|2022-11-06

10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎

阅读：7540|2022-11-06

客服电话

电子邮件

Canny算子c++

请发表评论

全部评论

上一篇：

下一篇：

revolunet/angular-carousel: Mobile frien

dphi-official/Machine_Learning_Bootcamp

juven/maven-bash-completion: Maven Bash

adrielcafe/AndroidAudioRecorder: A fancy

route101/mastoinker: Quick image view as

剪的笔顺,诠释剪的笔画,认识剪的部首

六六分期app的软件客服如何联系？(六六分期

florent37/ViewAnimator: A fluent Android

florent37/Shrine-MaterialDesign2: implem

CVE-2020-36276

SimpleSoftwareIO/simple-sms: Send and re

关于我们

产品与服务

解决方案

139-2527-9053