精华内容
下载资源
问答
  • 用Networkx进行有向图遍历
    千次阅读
    2021-01-29 23:27:58

    好吧,我要介绍的解决方案有点老套,但我愿意接受更多优化建议。在

    首先,我们将创建一个用于测试的虚拟图import networkx as nx

    G = nx.balanced_tree(2,4,create_using=nx.DiGraph())

    接下来,我们将使用networkx的dfs_treeAPI(使用最新版本),并使用depth_limit属性来提取深度为n和{}的树,其中n+1是用户输入的深度(因为它从1开始索引深度)

    ^{pr2}$

    然后对深度n+1执行相同的操作T2 = nx.dfs_tree(G, source=0,depth_limit=4)

    T2_edges =list(T2.edges())

    #[(0, 1), (0, 2), (1, 3), (1, 4), (2, 5), (2, 6), (3, 8), (3, 7), (4, 9), (4, 10), (5, 11), (5, 12), (6, 13), (6, 14), (7, 16), (7, 15), (8, 17), (8, 18), (9, 19), (9, 20), (10, 21), (10, 22), (11, 24), (11, 23), (12, 25), (12, 26), (13, 27), (13, 28), (14, 29), (14, 30)]

    现在来看看这两个列表的XORedges_left = list(set(T1_edges).symmetric_difference(T2_edges))

    #[(14, 30), (11, 23), (10, 21), (7, 16), (11, 24), (7, 15), (10, 22), (9, 20), (12, 25), (13, 28), (8, 17), (14, 29), (12, 26), (13, 27), (8, 18), (9, 19)]

    这些是3级的边。现在提取这些级别的节点nodes_at_level = set([x[0] for x in edges_left])

    #{7, 8, 9, 10, 11, 12, 13, 14}

    然后使用bfs_tree在这些节点提取树for n in nodes_at_level:

    tree = nx.bfs_tree(G, n)

    print tree.edges() #Do whatever you want with those subgraphs

    #[(7, 16), (7, 15)]

    #[(8, 17), (8, 18)]

    #[(9, 19), (9, 20)]

    #[(10, 21), (10, 22)]

    #[(11, 24), (11, 23)]

    #[(12, 25), (12, 26)]

    #[(13, 27), (13, 28)]

    #[(14, 29), (14, 30)]

    更多相关内容
  • ParseWord07Test(EasyPOi word隐藏边框+图片遍历导出) ParseWord07Test(EasyPOi word隐藏边框+图片遍历导出)
  • 用opencv来对文件夹内的图片进行遍历读取并进行批量操作,这里代码展示的是进行批量裁剪,可以根据不同需求来对图片进行不同的批量操作,比如裁剪、重命名等。方便
  • 图遍历的演示

    2018-01-14 12:48:13
    分别采用深度优先和广度优先对无向连通进行遍历 采用邻接表存储
  • 下面小编就为大家分享一篇vue2.0 循环遍历加载不同图片的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 亲测可用,注释详细,只需修改文件夹路径就ok。好用的话记得五星好评哦!
  • 无向图遍历

    2018-01-23 12:06:35
    无向主要包括双方面内容,遍历和寻找联通分量。 无向遍历 无向遍历有两种方式—广度优先搜索(BFS)和深度优先搜索(DFS)。广度优先搜索在遍历一个顶点的全部节点时,先把当前节点全部相邻节点遍历了。...
  • Python算法之遍历

    2020-12-25 02:11:22
    本节主要介绍遍历算法BFS和DFS,以及寻找的(强)连通分量的算法 Traversal就是遍历,主要是对图的遍历,也就是遍历图中的每个节点。对一个节点的遍历有两个阶段,首先是发现(discover),然后是访问(visit)。...
  • 图片遍历级显示

    2013-06-13 10:13:52
    遍历文件夹下的所有图片文件 以listview的形式展现出来 点击Item 显示大图片
  • 很多涉及上操作的算法都是以遍历操作为基础的。试写一个程序,演示无向遍历操作。 二.基本要求 以邻接表为存储结构,实现连通无向的深度优先和广度优先遍历。以用户指定的结点为起点,分别输出每种遍...
  • 在上个项目开发中遇到这样的需求,取指定目录下面的所有图片,以表格的型式展示并显示该图片的相对路径。下面小编给大家分享C# 遍历文件夹子目录下所有图片遍历文件夹下的文件,一起看看吧
  • 图遍历详解(C语言版)

    千次阅读 2021-04-28 08:13:51
    图遍历详解(C语言版):深度优先遍历、广度优先遍历、连通或强连通图遍历、非连通图遍历


    一、定义

            从给定图中任意指定的顶点(称为初始点)出发,按照某种搜索方法沿着图的边访问图中所有顶点,使每个顶点仅被访问一次,这个过程称为图的遍历。如果给定图是连通的无向图或者是强连通的有向图,则遍历过程一次就能完成,并可按访问的先后顺序得到由该图的所有顶点组成的一个序列。

    二、方法

            在遍历的过程中,从图的初始点到达图中的每个顶点可能存在多条路径。当沿着图中的一条路径访问过某顶点之后,可能还沿着另一条路径回到该顶点,即存在回路。为了避免同一个顶点被重复访问,需要设置一个访问标记数组visited,当顶点i,被访问过时,数组中的元素visited[i]置为1,否则置为0。
            图的遍历过程实际就是搜索过程,根据搜索方法的不同,图的遍历方法有两种:一种是深度优先遍历,另一种叫广度优先遍历。

    1、深度优先遍历

            深度优先遍历的过程是从图中的某个初始点v出发,首先访问初始点v,然后选择一个与顶点v相邻且没被访问过的顶点w,以w为初始顶点,再从它出发进行深度优先遍历,直到图中与顶点v邻接的所有顶点都被访问为止,显然这是一个递归过程。
            下面给出一个示例:

    在这里插入图片描述
            该图以A为初始点,从左往右通过深度优先遍历可以得到序列:ABDHECFG ,当然如果采取从右往左通过深度优先遍历可以得到序列:ACGFBEHD,可见采用深度优先遍历得到的序列并不是唯一的,这与建图时的存储有关,假如采用邻接表来存储,当每个顶点的邻接顶点采用头插法插入,那么之后采用深度优先遍历进行遍历时就会得到序列ACGFBEHD,当每个顶点的邻接顶点采用尾插法插入,那么之后采用深度优先遍历进行遍历就得到序列ABDHECFG。
            下面来看看深度优先遍历的代码

    //深度优先遍历:  g:图  v:初始点    visited:标记数组
    void DFS(GraphLnk *g, int v, bool visited[])
    {
    	//访问顶点,获取值,打印
    	printf("%c-->",GetVertexValue(g,v));
    	visited[v] = true;//为访问过的顶点做上标记
    	int w = GetFirstNeighbor(g,GetVertexValue(g,v));//获取第一个邻接顶点
    	while(w != -1)
    	{//当邻接顶点未被访问
    		if(!visited[w])
    		{
    			DFS(g,w,visited);//以该顶点为起始顶点进行深度优先遍历
    		}
    		/*
    		对第一个邻接顶点深度优先遍历完成,获取下一个邻接顶点的位置
    		(如果该顶点未被访问,那么下一轮将以该顶点为起始顶点进行深度优先遍历)
    		*/
    		w = GetNextNeighbor(g,GetVertexValue(g,v),GetVertexValue(g,w));
    	}
    }
    

    2、广度优先遍历

            广度优先遍历的过程是首先访问初始点v,接着访问顶点v的所有未被访问过的邻接点v1,v2,v3,…,vt,然后再按照v1,v2,v3,…,vt的次序访问每一个顶点的所有未被访问过的邻接点,依此类推,直到图中所有和初始点v有路径相通的顶点都被访问过为止。为了实现红色部分描述的先访问顶点的邻接顶点先访问,需要借用队列来实现。
            下面给出一个示例:

    在这里插入图片描述
            该图以A为初始点,从左往右通过广度优先遍历可以得到序列:ABCDEFGH ,当然如果采取从右往左通过广度优先遍历可以得到序列:ACBGFEDH,可见采用广度优先遍历得到的序列也并不是唯一的,原因同深度优先遍历不唯一的原因,此处不再赘述。
            下面来看看广度优先遍历的代码

    //广度优先遍历:g:图  v:初始点  visited:标记数组
    void BFS(GraphLnk *g, int v, bool visited[])
    {
    	printf("%c-->",GetVertexValue(g,v));
    	visited[v] = true;
    	
    	LinkQueue Q;//创建链队
    	InitQueue(&Q);//初始化
    
    	EnQueue(&Q,v);//将起始顶点入队
    	int w;
    	while(!Empty(&Q))//当队内还有顶点
    	{
    		GetHead(&Q,&v);//获取存在在队头的顶点v
    		DeQueue(&Q);//出队
    		//获取第一个邻接顶点
    		w = GetFirstNeighbor(g,GetVertexValue(g,v));
    		while(w != -1)//存在邻接顶点
    		{
    			if(!visited[w])//当该邻接顶点未被访问
    			{
    				//打印值
    				printf("%c-->",GetVertexValue(g,w));
    				visited[w] = true;//标记为已被访问
    				EnQueue(&Q,w);//将该顶点入队,为之后访问该顶点的邻接顶点做铺垫
    			}
    			//获取顶点v的下一个邻接顶点(该邻接顶点的顺序在前面访问过邻接顶点w之后)
    			w = GetNextNeighbor(g,GetVertexValue(g,v),GetVertexValue(g,w));
    		}
    	}
    }
    
    

    三、实现

            有了上面的理论基础,下面将基于图的邻接表存储来实现图的遍历,如果大家对图的邻接表存储方式还不太理解,那么可以先阅读图之邻接表详解(C语言版)此篇文章之后,再接着往下阅读。

    1、无向图或强连通有向图遍历

            如果给定图是连通的无向图或者是强连通的有向图,则遍历过程一次就能完成,并可按访问的先后顺序得到由该图的所有顶点组成的一个序列。

            深度优先遍历实现

    //深度优先遍历:给出遍历的图g和起始顶点vertex
    void DFS(GraphLnk *g, T vertex)
    {
    	int n = g->NumVertices;//获取顶点个数
    	//根据顶点数建立辅助数组空间:用来标记哪些顶点已经访问过,哪些顶点没有访问
    	bool *visited = (bool*)malloc(sizeof(bool) * n);
    	assert(visited != NULL);
    	for(int i=0; i<n; ++i)//初始化标记数组
    	{
    		visited[i] = false;
    	}
    	//获取起始节点在邻接表中的位置
    	int v = GetVertexPos(g,vertex);
    	DFS(g,v,visited);//遍历
    	free(visited);//释放辅助空间
    }
    

            广度优先遍历实现

    //广度优先遍历:给出遍历的图g和起始顶点vertex
    void BFS(GraphLnk *g, T vertex)
    {
    	int n = g->NumVertices;//获取顶点个数
    	//根据顶点数建立辅助数组空间:用来标记哪些顶点已经访问过,哪些顶点没有访问
    	bool *visited = (bool*)malloc(sizeof(bool) * n);
    	assert(visited != NULL);
    	for(int i=0; i<n; ++i)//初始化标记数组
    	{
    		visited[i] = false;
    	}
    	//获取起始顶点在邻接表中的位置
    	int v = GetVertexPos(g,vertex);
    	BFS(g,v,visited);//遍历	
    	free(visited);
    }
    

    2、非连通图遍历

            如果给定图是非连通图,则只能访问到初始点所在分量中的所有顶点,其他连通分量中的顶点是不可能访问到的,为此需要从其他每个连通分量中选择初始点,分别进行遍历,这样才能够访问到图中的所有顶点。

            深度优先遍历实现

    //非连通图的深度优先遍历方式
    void NonUnicomDFS(GraphLnk *g)
    {
    	int n = g->NumVertices;//获取顶点个数
    	//根据顶点数建立辅助数组空间:用来标记哪些顶点已经访问过,哪些顶点没有访问
    	bool *visited = (bool*)malloc(sizeof(bool) * n);
    	assert(visited != NULL);
    	for(int i=0; i<n; ++i)//初始化标记数组
    	{
    		visited[i] = false;
    	}
    	for(i=0; i<n; ++i) //遍历非连通图的顶点
    	{
    		if(!visited[i])//以没有访问的顶点为起始顶点进行深度优先遍历
    			DFS(g,i,visited);
    	}
    	free(visited);
    }
    

            广度优先遍历实现

    //非连通图的广度优先遍历方式
    void NonUnicomBFS(GraphLnk *g)
    {
    	int n = g->NumVertices;//获取顶点个数
    	//根据顶点数建立辅助数组空间:用来标记哪些顶点已经访问过,哪些顶点没有访问
    	bool *visited = (bool*)malloc(sizeof(bool) * n);
    	assert(visited != NULL);
    	for(int i=0; i<n; ++i)//初始化标记数组
    	{
    		visited[i] = false;
    	}
    	for(i=0; i<n; ++i) //遍历非连通图的顶点
    	{
    		if(!visited[i])//以没有访问的顶点为起始顶点进行广度优先遍历
    			BFS(g,i,visited);
    	}
    	free(visited);
    }
    

    结语

            对图遍历的介绍就到这里啦,希望这篇文章能给予你一些帮助,感谢各位人才的:点赞、收藏和评论,我们下次见。

    附录

            测试代码:图遍历详解(C语言版)

    展开全文
  • 遍历;复习-的存储结构;复习-的存储结构;复习-的存储结构;复习-的存储结构;复习-的存储结构;遍历;深度优先搜索;深度优先搜索;深度遍历序列;1从深度优先搜索遍历连通的过程类似于树的先根遍历 2...
  • OpenCV图像遍历的三种方式

    千次阅读 2020-05-06 00:27:48
    一、三种图像遍历方式与理解   在上一篇Blog中,介绍了使用基础图像容器Mat创建图像矩阵的六种方式 ,当我们使用创建的Mat矩阵进行图像处理时,需要对Mat矩阵中像素点进行遍历操作,图像像素点的遍历是任何图像...

    一、三种图像遍历方式与理解

      在上一篇Blog中,介绍了使用基础图像容器Mat创建图像矩阵的六种方式
    ,当我们使用创建的Mat矩阵进行图像处理时,需要对Mat矩阵中像素点进行遍历操作,图像像素点的遍历是任何图像处理算法必不可少的执行步骤。在OpenCV中提供了3种图像遍历的方法:

    • .at()函数访问
    • .ptr函数获取行指针逐行访问
    • iterator迭代器访问

    这三种方式在访问速度上有所差异,其中.at方法遍历速度最慢,但是代码可读性好;ptr指针遍历更快,但是指针操作没有类型检查和访问越界检查,即使程序在编译过程中没问题在执行过程中可能报错;iterator迭代器遍历方式最快而且安全不会出现访问越界情况,但是源码编辑稍显复杂。在编程过程中应该根据实践需要采取不同的遍历方式,以达到最高效的访问、读写和编辑。

    1、.at方法遍历
    Mat类提供了一个at的方法用于取得图像上的点,它是一个模板函数,通过image.at<Typename>(i,j)可以取到任何类型的图像上的点,其中typename标识像素类型,i和j分别表示图像image的行和列,读取Mat矩阵第i行j列像素的表示方法为:

    uchar pix_value = srcImage.at<uchar>(i,j); //读取srcImage第i行j列元素
    

    at方法遍历图像所有像素的一般格式为(srcImage表示原图):

    //单通道灰度图
    for(int i=0;i<srcImage.rows;i++){ 
    	for(int j=0;j<srcImage.cols;j++){
    		srcImage.at<uchar>(i,j)=...
    		...
    	}
    }
    
    //3通道RGB彩色图
    for(int i=0;i<srcImage.rows;i++){ 
    	for(int j=0;j<srcImage.cols;j++){
    		srcImage.at<Vec3b>(i,j)[2]=...  //R通道
    		srcImage.at<Vec3b>(i,j)[1]=...  //G通道
    		srcImage.at<Vec3b>(i,j)[0]=...  //B通道
    		...
    	}
    }
    

    【注】at方法只适合访问灰度值为8位的图像,即单通道图像,如灰度图、RGB分离单通道图等。

    2、指针访问
    指针访问图像像素的方式是利用C语言中的 “[]” 操作符,此时图像从上到下、从左到右可以看成是一个“一维数组”(不一定连续存储),通过Mat类成员变量cols和成员函数channels()获取图像宽和通道数,那么Mat矩阵第i行第j列元素可表示为: i ∗ s r c I m a g e . c o l s ∗ s r c I m a g e . c h a n n e l s ( ) + j i*srcImage.cols*srcImage.channels()+j isrcImage.colssrcImage.channels()+j为了简化指针运算,Mat类提供了ptr函数可以得到图像任意行首地址,它返回第i行的首地址:

    uchar* data = dstImage.ptr<uchar>(i);   //data为第i行像素首地址
    

    那么第i行第j列像素的标识方式简化为:data[i]+j

    ptr函数配合指针遍历图像所有像素的一般格式为(srcImage表示原图):

    //单通道灰度图
    for(int i=0;i<srcImage.rows;i++){
    	uchar* p=srcImage.ptr<uchar>(i);
    	for(int j=0;j<srcImage.cols;j++){
    		p[j]=...
    		...
    	}
    }
    
    //3通道RGB彩色图
    for(int i=0;i<srcImage.rows;i++){
    	Vec3b* p=srcImage.ptr<Vec3b>(i);
    	for(int j=0;j<srcImage.cols;j++){
    		p[j][2]=...  //R通道
    		p[j][1]=...  //G通道
    		p[j][0]=...  //B通道
    		...
    	}
    }
    

    3、iterator迭代器遍历
    这种方式类似STL,在访问图像矩阵时,仅仅需要获得图像矩阵的beginend元素,从begin遍历到end过程中,通过   ~  *   ~  操作符获取指针所指数据,即可访问Mat图像内容。
    iterator迭代器遍历图像所有像素的一般格式为(srcImage表示原图):

    //单通道灰度图
    MatIterator_<uchar> it_beg=srcImage.begin<uchar>();
    MatIterator_<uchar> it_end=srcImage.end<uchar>();
    for( , it_beg != it_end; it_beg++){
    	*it_beg=...
    	...
    }
    
    //3通道RGB彩色图
    MatIterator_<Vec3b> it_beg=srcImage.begin<uchar>();
    MatIterator_<Vec3b> it_end=srcImage.end<uchar>();
    for( , it_beg != it_end; it_beg++){
    	(*it_beg)[2]=...  //R通道
    	(*it_beg)[1]=...  //G通道
    	(*it_beg)[0]=...  //B通道
    	...
    }
    

    关于uchar与Vec3b类型一些问题:
    涉及到OpenCV中对图像像素的存储方式,一般情况下,单通道图像像素类型为uchar(unsigned char表示0-255区间的无符号整形),Vec是OpenCV一个模板类,表示一个向量,可表示多通道的图像像素类型,OpenCV预定义的一些类型有:

    typedef Vec<uchar, n> Vecnb;
    
    typedef Vec<short, n> Vecns;
    
    typedef Vec<int, n> Vecni;
    
    typedef Vec<float, n> Vecnf;
    
    typedef Vec<double, n> Vecnd;
    

    【注】n表示维度,可取2、3、4,分别表示2维向量、三维向量、四维向量,Vec3b就表示3维向量,每一个维度类型都是uchar型。

    二、C++实现三种方式对比

    下面通过一个demo程序,也是最通用的像素遍历示例程序来演示以上三种方法在遍历图像矩阵中的开销和优缺点
    Test: 颜色空间缩减

    加载一幅RGB彩色图像,使其颜色种类从256中变成64种。在颜色空间缩减方法中讲过这种方式,即每个像素值除以4向下取整然后再乘以4即可将其颜色种类缩减到64种。

    首先,为直观对比三种方式时间开销的差异,需要用到OpenCV提供的计时函数

    • getTickCount():返回CPU自某时间开始的时钟周期数
    • getTickFrequency():获取CPU时钟频率,即CPU每秒走的时钟周期数

    这两个函数配合使用即可计算出程序耗时,类似于C++中的clock()函数,具体用法如下:

    double time0 = static_cast<double>(getTickCount());  //记录起始时间
    //...
    //一系列操作
    //...
    time0 = ((double)getTickCount()-time0)/getTickFrequency();
    std::cout<<"..操作 运行时间为:"<<time0<<"s"<<std::endl; //输出运行时间
    

    Code:

    #include <iostream>
    #include <opencv2/opencv.hpp>
    
    using namespace cv;
    
    void colorReduceAt(Mat& srcImage, Mat& dstImageAt, int div);
    void colorReduceIterator(Mat& srcImage, Mat& dstImageIterator, int div);
    void colorReducePtr(Mat& srcImage, Mat& dstImagePtr, int div);
    
    int main()
    {
        //加载图像
        Mat srcImage = imread("");
    
        if(srcImage.empty())
        {
            cout << "Load failture...." << endl << endl;
            exit(-1);
        }
    
        //声明处理后图像变量
        Mat dstImageAt, dstImageIterator, dstImagePtr;
        dstImageAt = srcImage.clone();
        dstImageIterator = srcImage.clone();
        dstImagePtr = srcImage.clone();
    
        int div = 4;
    
        //声明时间变量
        double timeAt, timeIterator, timePtr;
    
        timeAt = static_cast<double>(getTickCount());
        colorReduceAt(srcImage, dstImageAt, div);
        timeAt = ((double)getTickCount() - timeAt) / getTickFrequency();
        imshow("dstImageAt",dstImageAt);
        cout << "使用at()动态地址计算耗时:" << timeAt << endl << endl;
    
        timeIterator = static_cast<double>(getTickCount());
        colorReduceIterator(srcImage, dstImageIterator, div);
        timeIterator = ((double)getTickCount() - timeIterator) / getTickFrequency();
        imshow("dstImageIterator",dstImageIterator);
        cout << "使用iterator迭代器耗时:" << timeIterator << endl << endl;
    
        timePtr = static_cast<double>(getTickCount());
        colorReducePtr(srcImage, dstImagePtr, div);
        timePtr = ((double)getTickCount() - timePtr) / getTickFrequency();
        imshow("dstImagePtr",dstImagePtr);
        cout << "使用ptr指针耗时:" << timePtr << endl;
    
    
        waitKey(0);
    
        return 0;
    }
    
    //使用at动态地址计算方式
    void colorReduceAt(Mat& srcImage, Mat& dstImageAt, int div)
    {
        int rowNumber = dstImageAt.rows;      //获取图像行数
        int colNumber = dstImageAt.cols;      //获取图像列数
    
        //对每个像素进行处理
        for(int i = 0; i < rowNumber; i++)
        {
            for(int j = 0; j < colNumber; j++)
            {
                dstImageAt.at<Vec3b>(i,j)[0] = dstImageAt.at<Vec3b>(i,j)[0]/div*div;    //Blue
                dstImageAt.at<Vec3b>(i,j)[1] = dstImageAt.at<Vec3b>(i,j)[1]/div*div;    //Green
                dstImageAt.at<Vec3b>(i,j)[2] = dstImageAt.at<Vec3b>(i,j)[2]/div*div;    //Red
            }
        }
    
    }
    
    //使用iterator迭代器方式
    void colorReduceIterator(Mat& srcImage, Mat& dstImageIterator, int div)
    {
        MatIterator_<Vec3b> imageIt = dstImageIterator.begin<Vec3b>();      //获取迭代器初始位置
        MatIterator_<Vec3b> imageEnd = dstImageIterator.end<Vec3b>();       //获取迭代器结束位置
    
        //对每个像素进行处理
        for(;imageIt != imageEnd; imageIt++)
        {
            (*imageIt)[0] = (*imageIt)[0]/div*div;      //Blue
            (*imageIt)[1] = (*imageIt)[1]/div*div;      //Green
            (*imageIt)[2] = (*imageIt)[2]/div*div;      //Red
        }
    }
    
    //使用ptr指针
    void colorReducePtr(Mat& srcImage, Mat& dstImagePtr, int div)
    {
        int rowNumber = dstImagePtr.rows;                           //获取图像矩阵行数
        int colNumber = dstImagePtr.cols*dstImagePtr.channels();    //三通道图像每行元素个数为列数x通道数
    
        for(int i = 0; i < rowNumber; i++)
        {
            uchar* pixelPtr = dstImagePtr.ptr<uchar>(i);            //获取矩阵每行首地址指针
            for(int j = 0; j < colNumber; j++)
                pixelPtr[j] = pixelPtr[j] / div * div;
        }
    }
    

    续更…
    参考博客:OpenCV成长之路(2):图像的遍历

    展开全文
  • 博文图遍历详解(C语言版)的测试代码,博文链接:https://blog.csdn.net/qq_44075108/article/details/116222906 详细介绍了基于邻接表存储的的深度优先遍历和广度优先遍历的实现
  • Opencv学习笔记之遍历图片

    千次阅读 2022-03-28 13:54:04
    Opencv基础中如何遍历图片的像素。

    Opencv中有很多的方法遍历图片,笔者列出所遇见的几种遍历图片元素的方法其实就是如何遍历矩阵。为了查看出几种遍历图形的的不同,代码中会通过chrono来计算每次遍历的时间。

    1、方法1:

    使用Opencv中的指针对获取的图形进行遍历。

    使用到Mat::ptr()此函数返回的是uchar类型,返回的是y行的第一个元素的指针。通过指针的话就可以实现对图片的遍历。我们处理的图形分别有彩色和灰度的,彩色图形一般是RGB这样需要遍历三个矩阵。就需要Mat::channels()返回的是通道数。RGB为3灰度为1。接下来我们就可以开始遍历图片了。

        chrono::steady_clock::time_ponit t1=chrono::steady_clock::now();
        for(seiz_t y=0;y<img.rows;y++
        {
            unsigned char* row_ptr=img.ptr<unsigned char>(y);//指向y行第一个元素的指针
            for(size_t x;x<img.cols;x++)
            {
                unsigned char *data_ptr=&row_ptr[x*img.channels()];//img.channnels返回的图形的通道数,rgb为3 灰度为1
                for(int c=0;c<img.channels();c++
                {
                     unsigned char datea=data_ptr[c];   
                }    
            }
        }
        chrono::duration<double> time_used =chrono::duration_cast<chrono::duration<double>>
        (t2-t1);
        cout<<"遍历图形时间:\n"<<time_used.count()<<"秒"<<endl;

    2、方法2:

    本方法就很简单直接使用Mat的对象进行遍历。废话不多说直接上代码!使用Mat::at(int row ,int col)对图形进行遍历

        chrono::steady_clock::time_point t3=chrono::steady_clock::now();
        for(int y=0;y<img.rows;y++)
        {
            for(int x=0;x<img.cols;x++)
            {
                
                for (int i = 0; i < img.channels(); i++)
                {
                    unsigned char data=img.at<cv::Vec3b> (y,x)[i];
                }
                
            }
        }
        chrono::steady_clock::time_point t4=chrono::steady_clock::now();
        chrono::duration<double> timecha=chrono::duration_cast<chrono::duration<double>>(t4-t3);
        cout<<"遍历图形时间:\n"<<timecha.count()<<"秒"<<endl;

    展开全文
  • 严蔚敏版的 图遍历的演示 数据结构课程设计,完美运行,里面注释详细
  • 问题描述: 设计算法,演示连通无向访问所有结点的过程。 功能要求: (1)以邻接表作为存储结构; (2)由用户指定遍历的起点; (3)实现深度优先和广度优先遍历; (4)输出深度优先遍历和广度优先遍历的结点...
  • 主要为大家详细介绍了python实现遍历文件夹图片并重命名,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 主要为大家详细介绍了C# 遍历文件夹及子目录下所有图片的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 有向图遍历

    2013-10-23 00:34:43
    有向图遍历int visited[m]; typedef struct node { int data; struct node *next; }linkqueuenode;
  • DFS 图遍历路径优化分析

    万次阅读 2021-12-29 15:09:51
    深度优先搜索是遍历的一种重要方法,在一些网络拓补结构、DNA 网络等复杂图形分析中有很广泛的应用。传统的深度优先搜索,从某一节点开始,依次遍历此节点所有相邻且未被访问的节点,其下一跳节点的选择往往不是...
  • 主要介绍了php遍历、读取文件夹中图片并分页显示图片的方法,涉及php针对文件与目录的遍历操作相关技巧,需要的朋友可以参考下
  • matlab实现文件中的所有图像统一处理,代码如下 file_path = 'F:\image\';...%对图像进行遍历的处理代码,如:调整图像大小为227×227 imwrite(ResizeImg,[path,num2str(j),'.jpg']) % 可以设置保存图像的格式 end end
  • 图遍历生成树的完美演示,即可从键盘输入来生成,又可从文件中读入
  • 1)创建一个; 2)的深度优先遍历的递归算法; 3)的深度优先遍历的迭代算法; 4)的广度优先遍历算法。
  • 图遍历演示

    2012-06-18 16:55:39
    C++编写的遍历演示源代码,很有代表性
  • 实验项目名称 遍历 一实验目的 应用所学的知识分析问题解决问题学会用建立并对其进行 遍历提高实际编程能力及程序调试能力 二实验内容 问题描述建立有向并用深度优先搜索和广度优先搜素输 入中节点的个数...
  • 使用Neo4j核心Java API进行遍历 第一种遍历方法是使用Neo4j核心Java API提供的标准方法。第一次遍历可以描述为“从代表用户John Johnson的节点开始, 查找这个用户看过的所有电影”。要导航到代表John已经看过的电影...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 834,449
精华内容 333,779
关键字:

图的遍历