精华内容
下载资源
问答
  • 以下是老师问题具体要求 求解最小生成树的Prim加点法和Kruskal加边法代码实现:分别以邻接矩阵和邻接表数据结构来表示和存储一个图(最好同时支持无向图和有向图),分别...在此基础上,借助OpenCV画出原来的图(...

    以下是老师问题具体要求
    求解最小生成树的Prim加点法和Kruskal加边法代码实现:分别以邻接矩阵和邻接表数据结构来表示和存储一个图(最好同时支持无向图和有向图),分别利用Prim加点法和Kruskal加边法求解其最小生成树,共四个求解函数(邻接矩阵+Prim加点法,邻接表+Prim加点法,邻接矩阵+Kruskal加边法,邻接表+Kruskal加边法)。在此基础上,借助OpenCV画出原来的图(顶点以数据域中的三个整数数值画相应颜色的圆,边以黑色的线条来表示),以红色的线条来取代黑色的线条表示得到的最小生成树上的边

    具体过程我会在代码中详细注释!
    图的数据具体参考我的二维数组

    #include <opencv.hpp>
    #include<stdio.h>
    #include<cstdio>
    #include<string.h>
    #include<math.h>
    #include<stack>
    #include<queue>
    #include<stdlib.h>
    #include <iostream>
    #define F 9999999
    using namespace cv;
    using namespace std;\\无视这么多头文件,我每次做作业直接复制这些的
    Mat srcImage1(600, 1000, CV_8UC3, Scalar(255, 255, 255));\\创建个白板 600×1000的
    int mape[12][12] = {
    {0,5,0,1,0,0,0,0,0,0,0,0},
    {5,0,6,0,0,0,8,0,0,0,0,0},
    {0,6,0,6,0,0,0,1,0,0,0,0},
    {1,0,6,0,0,0,3,0,0,0,0,0},
    {0,0,0,0,0,0,0,0,2,9,0,0},
    {0,0,0,0,0,0,0,0,0,0,4,0},
    {0,8,0,3,0,0,0,0,0,7,0,0},
    {0,0,1,0,0,0,0,0,0,0,0,3},
    {0,0,0,0,2,0,0,0,0,0,0,0},
    {0,0,0,0,9,0,7,0,0,0,3,0},
    {0,0,0,0,0,4,0,0,0,3,0,4},
    {0,0,0,0,0,0,0,3,0,0,4,0}\\ok 这就是我的图的数据,我接下来的邻接表直接根据这个数组存的
    };
    struct v {
    	int e;
    	int edist;
    	struct v *next;
    }*V[12];
    struct v *p[12];
    struct linkmape {
    	struct v *link;
    	int numb;
    }ML[12];\\我的ljb的定义
    struct Mape {
    	int Mapex;
    	int Mapey;
    	int numb;
    }M[12];
    stack<struct Mape> S;
    stack<struct linkmape> SS;
    queue<struct Mape>Q;
    queue<struct linkmape>QQ;\\懒得自己实现stack queue 用了c++模块,感兴趣的同学自己去学
    void draw()\\预存我每个节点在x,y上的具体位置,并画下来,draw 顾名思义
    {
    	int count = 0, y = 100, x = 200;
    	for (int i = 0; i < 12; i++)
    	{
    		if (count == 3)
    		{
    			y = y + 120;
    			count = 0;
    			x = 200;
    		}
    		M[i].numb = i;
    		M[i].Mapex = x;
    		M[i].Mapey = y;
    		count++;
    		x = x + 300;
    	}
    	for (int i = 0; i < 12; i++)
    	{
    		circle(srcImage1, Point(M[i].Mapex, M[i].Mapey), 50, CV_RGB(255, 0, 0), -1, 2);
    	}
    	for (int i = 0; i < 12; i++)
    	{
    		for (int j = 0; j < 12; j++)
    		{
    			if (mape[i][j])
    			{
    				line(srcImage1, Point(M[i].Mapex, M[i].Mapey), Point(M[j].Mapex, M[j].Mapey), Scalar(0, 0, 0), 2);
    				char text[10];
    				_itoa_s(mape[i][j], text, 10);
    				std::string st4 = text;
    				putText(srcImage1, st4, Point((M[i].Mapex+ M[j].Mapex)/2, (M[i].Mapey+ M[j].Mapey)/2), FONT_HERSHEY_SIMPLEX, 1, Scalar(0, 0, 0), 4, 8);\\puttext,具体实现方法看代码,数字先转换为string
    			}
    		}
    	}
    	imshow("显示图像", srcImage1);
    	waitKey();
    }
    void init()\\初始化并赋值我的ljb
    {
    	for (int i = 0; i < 12; i++)
    	{
    		V[i] = (struct v*)malloc(sizeof(struct v));
    		V[i]->e = i;
    		V[i]->next = (struct v*)malloc(sizeof(struct v));
    		p[i] = V[i]->next;
    		p[i]->e = -1;
    	}
    	for (int i = 0; i < 12; i++)
    	{
    		for (int j = 0; j < 12; j++)
    		{
    			if (mape[i][j])
    			{
    				p[i]->edist = mape[i][j];
    				p[i]->e = j;
    				p[i]->next = (struct v*)malloc(sizeof(struct v));
    				p[i] = p[i]->next;
    				p[i]->e = -1;
    			}
    		}
    	}
    	for (int i = 0; i < 12; i++)
    	{
    		ML[i].link = V[i];
    		ML[i].numb = i;
    	}
    }
    void primprehandle(int dist[],int parent[])\\预处理我的prim算法中的dist数组 and parent数组
    {
    	for (int i = 0; i < 12; i++)
    	{
    		if (mape[0][i])
    		{
    			dist[i] = mape[0][i];
    			parent[i] = 0;
    	    }
    	}
    }
    void linkprimprehandle(int dist[], int parent[])\\同上
    {
    	while (p[0]->e != -1)
    	{
    		dist[p[0]->e] = p[0]->edist;
    		parent[p[0]->e] = 0;
    		p[0] = p[0]->next;
    	}
    }
    void primshuzu(int dist[],int parent[])\\数组实现我的prim
    {
    	while (1) {
    		int min = F;\\先找最小的dist
    		int flag;
    		int count = 0;
    		dist[0] = -1;
    		for (int i = 0; i < 12; i++)
    		{
    			if (dist[i] == -1)count++;
    			if (dist[i] < min&&dist[i] != -1)
    			{
    				flag = i;
    				min = dist[i];
    			}
    		}
    		if (count == 12)\\若全都遍历了 break
    			break;
    		if (min == F)\\若已经没有一个有效数字在dist中,很明显可以得出结论不是联通图
    		{
    			printf("该图不连通!!\n");
    			return;
    		}
    		dist[flag] = -1;//收录
    		line(srcImage1, Point(M[parent[flag]].Mapex, M[parent[flag]].Mapey), Point(M[flag].Mapex, M[flag].Mapey), Scalar(0, 255, 0), 2);
    		imshow("图片", srcImage1);
    		waitKey();
    		for (int i = 0; i < 12; i++)
    		{
    			if (mape[flag][i] < dist[i] && flag != i&&mape[flag][i]!=0)
    			{
    				dist[i] = mape[flag][i];
    				parent[i] = flag;\\这里具体解释下parent 就是存你这个节点的上一个节点,不然咋知道点与点之间怎么走
    			}
    		}
    	}
    }
    void primlink(int dist[], int parent[],Mat t2)\\与数组prim大同小异 不解释啦
    {
     	while (1) {
    		int min = F;
    		int flag;
    		int count = 0;
    		dist[0] = -1;
    		for (int i = 0; i < 12; i++)
    		{
    			if (dist[i] == -1)count++;
    			if (dist[i] < min&&dist[i] != -1)
    			{
    				flag = i;
    				min = dist[i];
    			}
    		}
    		if (count == 12)
    			break;
    		if (min == F)
    		{
    			printf("该图不连通!!\n");
    			return;
    		}
    		dist[flag] = -1;//收录
    		line(t2, Point(M[parent[flag]].Mapex, M[parent[flag]].Mapey), Point(M[flag].Mapex, M[flag].Mapey), Scalar(0, 255, 0), 2);
    		imshow("图片", t2);
    		waitKey();
    		
    		while (p[flag]->e != -1)
    		{
    			if (p[flag]->edist < dist[p[flag]->e])
    			{
    				dist[p[flag]->e] = p[flag]->edist;
    				parent[p[flag]->e] = flag;
    			}
    			p[flag] = p[flag]->next;
    		}
    	}
    }
    void findmin(int mape[][12], int weight[][12],int *start,int *end)\\找最小边,start end 是端点,记住加指针,希望你们没有忘记上学期的指针知识哟,具体实现很简单,不过多解释啦
    {
    	int min = F,flag1,flag2;
    	for (int i = 0; i < 12; i++)
    	{
     	for(int j=0;j<12;j++)
    		if (mape[i][j])
    		{
    			if (mape[i][j] < min&&weight[j][i]!=1&&mape[i][j]!=0)
    			{
    				min = mape[i][j];
    				*start = i;
    				*end = j;
    				if (i == 3 && j == 6 || i == 6 && j == 3)
    					i = 3;
    			}
    		}
    	}
    	weight[*end][*start] = 1;
    	weight[*start][*end] = 1;
    
    }
    int s[12] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1};
    int find(int s[], int x)
    {
    	for (; s[x] >= 0; x = s[x]);
    	return x;
    }
    void Union(int s[], int v1, int v2)
    {
    	if (s[v2] < s[v1])
    	{
    		s[v2] += s[v1];
    		s[v1] = v2;
    	}
    	else {
    		s[v1] += s[v2];
    		s[v2] = v1;
    	}
    
    }
    void kruskal(int weight[][12],Mat t1,int parent[])\\当当当!克鲁斯卡尔算法来啦我用了并查集,对这个概念不清楚的同学们自行百度!(我的另一篇小破文里面可能有提到?)
    {
    	int count = 0;
    	while (1)
    	{
    		int start=-1, end=-1;
    		
    		if (count == 11)\\所有端点已经被联通
    			break;
    		findmin(mape, weight, &start, &end);
    		if(count != 12 && start != -1)
    		{
    			if (find(s, start) == find(s, end))
     				start = start;\\说明如果加了这条边就变成循环了!不做任何处理,为什么多次一举start=start是因为可以用来设置断点2333
    			if (find(s, start) != find(s, end))
    			{
    				Union(s, find(s,start), find(s,end));\\归入一个并查集中
    				line(t1, Point(M[start].Mapex, M[start].Mapey), Point(M[end].Mapex, M[end].Mapey), Scalar(0, 255, 0), 2);
    				imshow("图片", t1);
    				waitKey();
    				parent[end] = start;
    				parent[start] = end;\\存入路径
    				count++;
    			}
    
    		}
    	}
    }
    int s1[12] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
    struct v* findminlink(int weight[][12], int *start)
    {
    	struct v *temp=NULL;
    	int min = F, flag1, flag2;
    	for (int i = 0; i < 12; i++)
    	{
    		p[i] = V[i]->next;
    		while (p[i]->e != -1)
    		{
    			if (p[i]->edist < min&&weight[i][p[i]->e]!=1)
    			{
    				*start = i;
    				temp = p[i];
    				min = p[i]->edist;
    			}
    			p[i] = p[i]->next;
    		}
    		p[i] = p[i]->next;
    	}
    	weight[temp->e][*start] = 1;
    	weight[*start][temp->e] = 1;
    	return temp;
    }
    void kruskallink(int weight[][12], Mat t3, int parent[])\\同上
    {
    	int count = 0;
    	struct v *temp=NULL;
    	while (1)
    	{
    		int start = -1, end = -1;
    
    		if (count == 11)
    			break;
    		
    		temp=findminlink(weight,&start);
    		if (count != 12 && start != -1)
    		{
    			if (find(s1, start) == find(s1, temp->e))
    				start = start;
    			if (find(s1, start) != find(s1, temp->e))
    			{
    				Union(s1, find(s1, start), find(s1, temp->e));
    				line(t3, Point(M[start].Mapex, M[start].Mapey), Point(M[temp->e].Mapex, M[temp->e].Mapey), Scalar(0, 255, 0), 2);
    				imshow("图片", t3);
    				waitKey();
    				parent[temp->e] = start;
    				parent[start] = temp->e;
    				count++;
    			}
    
    		}
    	}
    }
    
    int main()
    {
    	init();
    	draw();
    	Mat t1, t2, t3;
    	srcImage1.copyTo(t1);
    	t1.copyTo(t2);
    	t2.copyTo(t3);
    	int parent[12] = { -1,-1,-1,-1,-1,-1,-1,- 1,-1,-1,-1,-1 };
    	int shuzudist1[12] = { F,F,F,F,F,F,F,F,F,F,F,F };
    	primprehandle(shuzudist1,parent);
    	primshuzu(shuzudist1, parent);
    	int parent2[12] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
    	int linkparent[12] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
    	int linkdist[12] = { F,F,F,F,F,F,F,F,F,F,F,F };
    	int weight[12][12] = { 0 };//判断该边是否有被取到(无向图时使用)
    	kruskal(weight, t1, parent2);
    	for (int i = 0; i < 12; i++)
    		p[i] = V[i]->next;
    	linkprimprehandle(linkdist, linkparent);
    	primlink(linkdist, linkparent, t2);
    	memset(weight, 0, sizeof(weight));
    	int linkparent2[12] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 };
    	kruskallink(weight, t3, linkparent2);
    }
    
    展开全文
  • 在利用C语言处理数组时,我们经常需要将图片的二维数组进行可视化;所以本文分享了一种利用OpenCV读取和生成图片的方法。 1. 利用OpenCV读取图片 前提条件: 本文的程序是在visual Studio2012中执行的; vs已经...

    利用OpenCV实现C++语言中二维数组的图像显示

    在利用C++语言处理数组时,我们经常需要将图片的二维数组进行可视化;所以本文分享了一种利用OpenCV读取和生成图片的方法。

    1. 利用OpenCV读取图片

    前提条件:

    • 本文的程序是在visual Studio2012中执行的;
    • vs已经配置好调用OpenCV需要的设置,如包含库目录,库文件等;
    • 在当前文件夹下有一幅名为“1”的.jpg格式的图片;

    在满足上述条件的情况下,执行如下程序,可读取1.jpg这幅图片。

    如何读取不同的图片,如何变通?

    关键的命令是:

    “imread(filename,option)”

    变通只要将filename变换为对应的“文件名”或者“路径+文件名”即可,注意程序里的双引号要用英文格式的。通过选择option可用不同的方式读取图片,本文是灰度读取“IMREAD_GRAYSCALE”。

    程序:

    #include "opencv.hpp"
    #include "highgui.hpp"
    using namespace cv;
    int main()
    {
        Mat image=imread("1.jpg",IMREAD_GRAYSCALE);
        cvNamedWindow("source image");
        imshow("source image",image);
        waitKey();
    }
    

    运行结果如下:

    完整的结果:

    2. 利用OpenCV实现C++语言中二维数组的可视化

    仔细理解第一部分的程序,你就可以知道OpenCV显示图像是通过这一命令实现的:

    “imshow("source image",image)

    其中"source image"是打开图片窗口的名称,image就是你的Mat类型的变量。

        对于C++语言的二维数组,它一般为数值类型(整形、浮点型、字符串等等),所以无法直接进行可视化,需要将二维数组的类型赋值给Mat类型的变量。

    给Mat类型的变量(假设为B)进行赋值需要执行命令:

    “B.data[i] = 255;”

    这里涉及到对象(结构体)的知识,你不理解也没关系,只要认为B.data就是Mat类型变量的数组就可以,如B.data[0],就是访问数组的第一个元素;B.data是一个一维数组,所以二维数组进行赋值时需要将元素对应到一维数组上。

    实现程序如下:

    #include "opencv.hpp"
    #include "highgui.hpp"
    #include "math.h"
    using namespace cv;		
    
    int main()
    {
        const int M = 300,N = 400;	//图片的行、列像素
        int data[M][N] = {0};		//创建一个200×200的数组
        //下面循环产生一个沿对角线变大的数组
        for(int i=0;i<M;i++)
            for(int j=0;j<N;j++)
                data[i][j] = (int)(255*sqrt(i*i+j*j)/500);	
        Mat B = Mat(M,N,CV_8UC1);	//创建一个M×N大小的变量
        for(int i=0;i<M;i++)
        {
        for(int j=0;j<N;j++)
            {
                B.data[i*N+j]=data[i][j];
            }
        }
        cvNamedWindow("source image1");
        imshow("source image1",B);
        waitKey();
        return 0;
    }

    执行结果如下:

    完整的结果:

    3. 结论

    利用Mat类型的.data性质进行变量访问,就可以实现二维数组赋值给Mat类型变量了,进而利用OpenCV的imshow命令将结果可视化。

    展开全文
  • data import get_data from my_data import get_figure2draw def BucketSort(ds): """ 桶排序只适用于整数排序,且最大元素不能比数值元素大太多 空桶[ 待排数组[ 0 ] ] = 待排数组[ 0 ] """ assert isinstance(ds, ...

    参考修改
    ZQPei的GitHub Sorting_Visualization 项目链接
    修改后笔者GitHub项目链接

    以下仅列举出对原脚本有修改的排序算法

    windows 环境下

    0-选择排序(SelectionSort)

    # 加载包 
    import sys 
    import os  
    
    
    root_path = 'D:/Python_data/gihub_project/sorting_va_20190620' #'E:/Python Data/Sorting_v'
    sys.path.append(root_path)
    from my_data import get_data
    from my_data import get_figure2draw
    
    
    def SelectionSort(ds):
        assert isinstance(ds, get_figure2draw), "Type Error"
    
        Length = ds.length
        for i in range(Length):
            swap_bool = True
            while swap_bool and i < Length - 1: # 优化: 交换一次就停止 
                for j in range(i, Length):
                    if ds.data[j] < ds.data[i]:
                        ds.swap(i,j)
                        swap_bool = False
    
    
    
    if __name__ == "__main__":
        data = get_data(100)
        ds = get_figure2draw(data, sort_title = 'SelectionSort')
        ds.Visualize() # 画出底图
        SelectionSort(ds)
        ds.set_time_interval(0)
        ds.Visualize() # 画出排序结束后的图
        try:
            sys.path.remove(root_path)
        except:
            pass
    

    优化前后时间排序时间对比
    在这里插入图片描述

    1- 桶排序(BucketSort)

    
    # 加载包 
    import sys 
    import os  
    import copy
    
    root_path = 'E:/Python Data/Sorting_v'
    sys.path.append(root_path)
    from my_data import get_data
    from my_data import get_figure2draw
    
    
    def BucketSort(ds):
        """
        桶排序只适用于整数排序,且最大元素不能比数值元素大太多
        空桶[ 待排数组[ 0 ] ] = 待排数组[ 0 ]
        """
        assert isinstance(ds, get_figure2draw), "Type Error"
        assert isinstance(ds.data[0], int), "Type Error"
    
        Lengh = ds.length
        dt = ds.data
        bucket = [0 for _ in range(max(dt) + 1)]
        for i in range(Lengh):
            bucket[ dt[i] ] = dt[i] 
    
        j = 0
        for i in range(Lengh):
            tmp = bucket[i] 
            while tmp != 'stp': # 有值位置才排序
                ds.set_val(j , tmp)
                tmp = 'stp'
                j += 1
    
    
    if __name__ == "__main__":
        data = get_data(64)
        ds = get_figure2draw(data, sort_title = 'BucketSort')
        ds.Visualize() # 画出底图
        BucketSort(ds)
        ds.set_time_interval(0)
        ds.Visualize() # 画出排序结束后的图
        try:
            sys.path.remove(root_path)
        except:
            pass
    
    

    2- 圈排序(CycleSort)

    
    import sys 
    import os  
    
    
    root_path = 'E:/Python Data/Sorting_v'
    sys.path.append(root_path)
    from my_data import get_data
    from my_data import get_figure2draw
    
    
    
    def CycleSort(ds):
        """
        环排序只适用于整数排序,且数正好范围在[0,N-1]内,且只有少量重复元素,不稳定
        """
        assert isinstance(ds, get_figure2draw), "Type Error"
        assert isinstance(ds.data[0], int), "Type Error"
    
        Length = ds.length
        dt = ds.data
        # 重复元素的列表
        repeatIdxs = []
        for i in range(Length):
            currIdx = i
            # 查找当前值应该所在的索引 
            shouldIdx = sum([1  if dt[currIdx] > v else 0 for v in  dt ])
            # cycle 跑圈 (忽视重复值)
            while currIdx != shouldIdx and dt[currIdx] != dt[shouldIdx]: # 当前位置不是应该所在的位置的时候
                ds.swap(currIdx, shouldIdx) # 交换 currIdx, shouldIdx 的值
                shouldIdx = sum([1 if dt[currIdx] > v else 0 for v in  dt ])
            # 可能包含重复的值记录
            if dt[currIdx] == dt[shouldIdx] and  currIdx != shouldIdx:
                repeatIdxs.append([currIdx, shouldIdx])
        # 重复元素插值
        for rep in repeatIdxs:
            if dt[rep[0]] == dt[rep[1]]:
                ds.set_val(rep[0], dt[max(rep[0] - 1, 0)])
                
    
    
    if __name__ == "__main__":
        # data = get_data(64)
        data = [51, 8, 46, 18, 40, 20, 14, 33, 5, 10, 62, 48, 53
        , 56, 0, 60, 6, 42, 39, 57, 25, 54, 59, 24, 19, 55, 32, 30
        , 58, 38, 29, 50, 49, 22, 44, 3, 7, 28, 16, 26
        , 41, 52, 4, 23, 35, 31, 36, 43, 61, 17, 37, 13
        , 45, 15, 9, 34, 47, 12, 27, 21, 11, 63, 2, 1, 2, 13, 2, 8]
        ds = get_figure2draw(data, sort_title = 'CycleSort')
        ds.Visualize() # 画出底图
        CycleSort(ds)
        ds.set_time_interval(0)
        ds.Visualize() # 画出排序结束后的图
        try:
            sys.path.remove(root_path)
        except:
            pass
    

    3- 堆排序(HeapSort)

    # 加载包
    import sys
    import os
    
    
    root_path = 'E:/Python Data/Sorting_v'
    sys.path.append(root_path)
    from my_data import get_data
    from my_data import get_figure2draw
    
    
    def big_endian(ds, root, end):
        """
        将堆的末端子节点作调整,使得子节点永远小于父节点  
        :param: ds    get_figure2draw  
        :param: root int 开始(list index)  
        :param: end int 结束(list index)  
        """
        arr = ds.data
        child = root * 2 +  1 # 左子节点
        while child <= end: 
            if child + 1 <= end and arr[child] < arr[child + 1] :
            # 判断右child是否存在,如果存在则和另外一个同级节点进行比较
                child += 1
            if arr[root] < arr[child]:
                ds.swap(root, child)
                ## 下钻到下层
                root = child
                child = root * 2 + 1
            else:
                break
    
    def HeapSort(ds): 
        """
    	堆排序
        """
        Length = ds.length - 1
        first = Length // 2 
        for root in range(first, -1, -1):
        # 建堆
            big_endian(ds, root, Length)
        for end in range(Length, 0, -1):
            # 堆顶是最大的值,放到最末尾,长度-1后继续建堆
            ds.swap(0, end) 
            big_endian(ds, 0, end - 1) 
    
    
    if __name__ == "__main__":
        data = get_data(64)
        ds = get_figure2draw(data, sort_title = 'HeapSort')
        ds.Visualize() # 画出底图
        HeapSort(ds)
        ds.set_time_interval(0)
        ds.Visualize() # 画出排序结束后的图
        try:
            sys.path.remove(root_path)
        except:
            pass
    
    展开全文
  • 相比于Matlab,VS2017在调试的时候没那么方便,尤其是...可以很好的帮助我们查看矩阵不同位置的具体数值,提高调试效率。 ImageWatch下载地址:https://marketplace.visualstudio.com/items?itemName=VisualCPPTeam.Ima

    相比于Matlab,VS2017在调试C++代码的时候没那么方便,尤其是针对矩阵进行查看的时候,得一步步打印,而ImageWatch is a watch window for viewing in-memory bitmaps when debugging native C++ code.可以很好的帮助我们查看矩阵不同位置的具体数值,提高调试效率。QT也是很好的调试工具,任选一个即可。

    一、ImageWatch的安装

    ImageWatch下载地址:https://marketplace.visualstudio.com/items?itemName=VisualCPPTeam.ImageWatch2017

    在这里插入图片描述
    直接安装即可,记得将VS2017关闭后在进行Image Watch的安装。安装后在代码中设置断点,运行程序,之后在“视图”–“其他窗口”–“Image Watch”,便可以显示当前内存的所有二维矩阵,如下,
    在这里插入图片描述
    放大后可以查看具体数值
    在这里插入图片描述

    二、QT环境搭建

    2.1 QT安装

    下载地址:http://www.qtcn.org/bbs/read-htm-tid-1075.html
    本文选用版本5.12.0:http://download.qt.io/archive/qt/5.12/5.12.0/
    无需注册:
    在这里插入图片描述
    安装勾选内容:
    在这里插入图片描述

    2.2 插件安装

    装完QT后还需要安装插件才能在VS2017中调用,打开vs2017,“工具 > 扩展和更新>联机”搜索qt,并下载
    在这里插入图片描述
    但直接下载速度太慢了(不知道是不是个人原因),可以直接下载插件并安装:http://download.qt.io/development_releases/vsaddin/2.6.0/
    下载完成后,双击运行,如下界面
    在这里插入图片描述
    配置QT工作目录
    QT插件安装成功后,会在菜单栏找到QT VS Tools
    在这里插入图片描述
    选择“QT Options”
    在这里插入图片描述

    三、opencv常见的矩阵Mat类运算(实时更新)

    1.reshape函数

    cv::Mat::reshape(int cn, int rows=0)
    

    cn为通道数,默认为0则保持原通道数不变
    rows为reshape后矩阵的行数,默认为0则保持原行数不变

    2.矩阵转置

    cv::Mat B
    cv::Mat A = B.t()
    

    A即为B矩阵的装置

    3.数据格式

    CV_32FC2
    32:32bits
    F:Float浮点型
    C:通道数,C2代表双通道,如常见的虚数矩阵存储,a+bi类型的数据,一个通道存实部,一个通道存虚部

    4.矩阵最大、小值–minMaxLoc函数

    minMaxLoc(src, minVal, maxVal, minLoc, maxLoc)
    

    输入:
    src为目标矩阵
    输出:
    minVal、maxVal:最小值、最大值
    minLoc、maxLoc:最小值位置坐标、最大值位置坐标
    注意:用法如下,minMaxLoc的输出对象应填写指针,如下面例子&maxVal,&maxLoc

    cv::Point2i maxLoc;
    double maxVal;
    cv::minMaxLoc(response, NULL, &maxVal, NULL, &maxLoc);
    
    展开全文
  • HOG特征提取全Numpy实现 ... extract 是提取cell中的HOG特征,然后可视化,在提取block中的HOG特征(主要流程) global_gradient 用于得到图片梯度幅度和梯度方向(在统计HOG特征前面需要得到的信息) ...
  • 数据可视化总结

    千次阅读 2017-11-12 15:30:09
    数据可视化工具整理(一)、Python数据挖掘相关扩展库 Numpy 提供数组支持,以及相应的高效的处理函数 Scipy 提供矩阵支持,以及矩阵相关的数值计算模块 Matplotlib 数据可视化工具,作图库 Pandas 强大、灵活的数据...
  • Dlib模型之驾驶员疲劳检测总结(可视化界面)

    万次阅读 多人点赞 2019-12-26 18:47:12
    目录序目的技术背景正文(1)环境搭建(1.1)opencv3.4.1图像处理(1.2)dlib人脸识别库(1.3)wxFromBuilder可视化界面(2)检测原理(3)wxpython主要控件(3.1)选择(3.2)打开本地视频(3.3)opencv图转...
  • 详解PyTorch项目使用TensorboardX进行训练可视化

    万次阅读 多人点赞 2019-02-28 21:38:13
    本文是对TensorboardX 各项功能的完整介绍,每项都包含了示例,给出了可视化效果,希望可以方便大家的使用。笔者水平有限,还请读者们斧正,相关问题可以在留言区提出,我尽量解答。 配置TensorboardX 环境要求 ...
  • plt.imshow 可视化遇到的问题

    千次阅读 2020-12-28 01:51:51
    参考文档: matplotlib.pyplot.imshow 官方文档 plt.imshow()将灰度图像...RGB2BGR 是转换后的图(opencv图像操作需要),opencv使用BGR,matplotlib使用RGB,混用时显示会有差别 transforms_image 是初始之后的图 初
  • 用tk做可视化界面 cv2显示图片 临时拼凑的代码 pygraphviz 没有找到显示图片的代码,就用opencv imshow来显示了,如果哪个地方不尽人意还请多多包涵,或提醒我进行改善 pygraphviz 适用于python3.x版本的:...
  • 简单运用opencv实现图形校园导游&地图导航系统

    千次阅读 热门讨论 2018-02-06 19:32:54
    图形显示和放大镜功能提供 提供两点间所有路径查询动态演示、将所有的路径存入链表中便于后期筛选 本文主要介绍的是整个系统的概述,加粗部分模块包括其代码及算法将另开文详细介绍 技术实现 文件存储有
  • 文章目录tensorboardX安装使用建立event writer实体记录数值记录图像记录直方图、声音、文字记录网络框架查看Example...tensorboardX是为了非tensorflow框架也可以使用tensorboard的可视化功能而开发的。 学习...
  • Python+OpenCV实时图像处理

    万次阅读 多人点赞 2020-01-04 23:09:35
    初学OpenCV图像处理的小伙伴肯定对什么高斯函数、滤波处理、阈值二值等特性非常头疼,这里给各位分享一个小项目,可通过摄像头实时动态查看各类图像处理的特点,也可对各位调参、测试有一定帮助。
  • 目录TensorBoardX安装Create a summary writerGeneral api formatAdd scalarAdd imageAdd histogramAdd figureAdd graphAdd audioAdd embedding(高维度张量可视化/降维)查看数据可视化效果官方demo示例:可视化loss...
  • Deep Visualization:可视化并理解CNN

    万次阅读 2017-09-26 14:59:41
    文中介绍了一种新的可视化方法,借助它,我们可以深入了解中间层和分类器的功能。通过使用类似诊断的方式,作者还得到了比AlexNet更好的结构:ZFNet;
  • 卷积神经网络实现图像识别及过程可视化

    万次阅读 多人点赞 2018-06-12 17:53:15
    卷积神经网络实现图像识别及过程可视化 本博文提供经典的卷积神经网络实现代码,将CNN的工具类等代码分别封装,并提供接口自行替换使用的模型(可以换成自己的神经网络及图片样本),代码中提供模型保存和读取...
  • 数据可视化是数据科学家的重要部分。创建可视化的目的:探索数据,交流数据。 matplotlib的配置  许多工具可以可视化数据,目前应用很广的是matplotlib库,在windows下配置该模块稍微比较麻烦,下面会一步一步...
  • 特征可视化

    千次阅读 2019-04-29 14:34:29
    OpenCV中使用applycolormap(伪彩色函数) OpenCV的定义12种colormap(色度图),可以应用于灰度图像,使用函数applycolormap产生伪彩色图像。让我们很快看到如何将色度图的一种模式colormap_jet应用到一幅图像中...
  • 这一节是对上面一节分类的图片进行可视化的,前面的部分基本是一样的,就是载入模块、路径、图片、向前分类,具体程序如下: //需要的模块,设置好路径和绘图参数,全写在前面了 import numpy as np import ...
  • 可视化之瀑布图的绘制--基于matplotlib库第一步:前期准备-导入数据第二步:打好基础1-画出堆叠柱形图的样子第三步:打好基础2-并排柱形图第四步:瀑布图成形第五步:瀑布图优化1-柱体上加数字标注第六步:瀑布图...
  • 【caffe-matlab】权重以及特征图的可视化

    万次阅读 多人点赞 2016-09-23 22:26:56
    移植了各种caffe,是时候进行下一步操作了,先拿可视化下手吧。大部分内容可能跟网上的方法不一样,大家看完我的博客最好去网上看看大牛们的博客,万一被我误导了,就罪过了o(╯□╰)o,开更............. 环境:...
  • 这一节是对上面一节分类的图片进行可视化的,前面的部分基本是一样的,就是载入模块、路径、图片、向前分类,具体程序如下://需要的模块,设置好路径和绘图参数,全写在前面了 import numpy as np import ...
  • 点击上方“计算机视觉工坊”,选择“星标”干货第一时间送达导读可视化对于Transformer的模型调试、验证等过程都非常重要,FAIR的研究者开源了一种Transformer可视化新方法...
  • 在Keras中可视化LSTM

    千次阅读 2020-03-10 13:39:52
    作者|Praneet Bomma 编译|VK ... 你是否想知道LSTM层学到了什么?有没有想过是否有可能看到每个单元如何对最终输出做出贡献。我很好奇,试图将其可视化。在满足我好奇的神经元的同时,我偶然发现了Andrej Karpat...
  • 腹盆腔三维可视化系统的设计与实现 宁国玺. 腹盆腔三维可视化系统的设计与实现[D].山西大学,2020. 介绍: 本文基于使用 Opencv、VTK、ITK 和 Qt 工具包,完成了从二维医学图像序列到三维立体器官模型这一过程,并对...
  • 光流场可视化图解

    千次阅读 2018-12-20 15:31:23
    维度2中存储了2个数值,分别为0,1,0代表axis=0方向,也就是二维图像中的行方向,axis=1代表图像中的列方向。 综上: 1.可以得出结论光流场中[384,512,0]存储的速度方向为左右,速度方向朝左为+,速度方向朝右为-...
  • 这里给大家推荐一个本人开发的基于OpenCV的ImageWatch模块 (大家可以直接引入自己的项目), 方便大家在算法开发过程中可视化图像. 示例图: 这个模块可以支持如下的功能: 支持鼠标拖动图像 支持滚轮缩放图像 支持图片...
  • 光流转RGB可视化的C++实现

    千次阅读 2018-07-27 11:22:58
    将稠密光流场按照孟塞尔颜色体系(Munsell Color System)转化为RBG图,这个其实没什么卵用,只不过是开发光流估计算法或者光流应用时提供一种结果可视化的途径。 实现过程时参照python版本的flownet2提供的代码。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,741
精华内容 1,496
关键字:

opencv数值可视化