图矩阵_散点图矩阵 - CSDN
精华内容
参与话题
  • 计算机图形学视图矩阵推导过程

    千次阅读 2019-03-24 23:51:06
    视图矩阵推导过程(Demo基于WebGL 2.0实现) 一、概述 首先,我们需要了解些概念: 摄像机坐标系或者摄像机空间:物体经摄像机观察后,进入摄像机空间。 视变化,是将世界坐标系下的坐标变化到摄像机坐标系,视...

    视图矩阵推导过程(Demo基于WebGL 2.0实现)

    一、概述

    首先,我们需要了解些概念:

    摄像机坐标系或者摄像机空间:物体经摄像机观察后,进入摄像机空间。

    视变化,是将世界坐标系下的坐标变化到摄像机坐标系,视变换是通过乘以视图矩阵实现的。

            我们要知道视并不存在真正的摄像机,只不过是在世界坐标系里面选择一个点,作为摄像机的位置。然后根据一些参数,在这个点构建一个坐标系。然后通过视图矩阵将世界坐标系的坐标变换到摄像机坐标系下。

           WebGL成像采用的是虚拟相机模型。在场景中你通过模型变换,将物体放在场景中不同位置后,最终哪些部分需要成像,显示在屏幕上,主要由视变换和后面要介绍的投影变换、视口变换等决定。其中视变换阶段,通过假想的相机来处理矩阵计算能够方便处理。对于WebGL来说并不存在真正的相机,所谓的相机坐标空间(camera space 或者eye space)只是为了方便处理,而引入的坐标空间。

           完整变换流程概述可见:https://blog.csdn.net/weixin_37683659/article/details/79622618

    二、推导目标

           我们先简单说一下我们的目标,在世界坐标系中选取一点作为观察点,并以观察点建立一个坐标系,以观察点建立的坐标系就是我们需要的摄像机坐标系,在建立此坐标系后,我们做的就是通过矩阵将世界坐标系下点的坐标变换到摄像机坐标系下。

    三、线性代数的准备

           我们首先要了解线性代数中的基变换与坐标变换:

    基变换:

    坐标变换:

        

    坐标变换公式证明:

          

    上述是同济大学线性代数书中的一部分。

    四、推导过程

           1、构建摄像机坐标系:

                  摄像机9参数:

                视点:相机在世界坐标中的位置 eye(eyeX, eyeY, eyeZ)

                观测点:被观察的目标点,指明相机的朝向 at(atX, atY,atZ)

                顶部朝向:确定在相机哪个方向是向上的,一般取(0, 1, 0) up(upX,upY, upZ)

                如下图所示(截图来自《交互式计算机图形学》):

                        

           在使用过程中,我们是要指定的参数即为摄像机位置(eye),摄像机指向的目标位置(target)和摄像机顶部朝向(up)向  量三个参数。

           Step1 : 首选计算摄像机镜头方向 forwrad=(target−eye),

                        进行归一化forward=forward/|forwrad|。

           Step2: 根据up vector和forward确定摄像机的side向量:

                        归一化up vector:viewUp′=viewUp/|viewUp|。

                        叉积:side=cross(forward,viewUp′)

            Step3 : 根据forward和side计算up向量:
                        叉积:up=cross(side,forward)(注意此up向量是垂直于forward和side构成的平面)
           这样eye位置,以及forward、side、up三个基向量构成一个新的坐标系,注意这个坐标系是一个左手坐标系,因此在实际使用中,需要对forward进行一个翻转,利用-forward、side、up和eye来构成一个右手坐标系,称为观察坐标系或者u-v-n坐标系。

           我们的目标是计算世界坐标系中的物体在摄像机坐标系下的坐标,也就是从相机的角度来解释物体的坐标。从一个坐标系的坐标变换到另一个坐标系,这就是不同坐标系间坐标转换的过程。

           2、利用旋转和平移矩阵求逆矩阵

            将世界坐标系旋转和平移至于相机坐标系重合,这样这个旋转R和平移T矩阵的组合矩阵M=T∗R,就是将相机坐标系中坐 标变换到世界坐标系中坐标的变换矩阵,那么所求的视变换矩阵(世界坐标系中坐标转换到相机坐标系中坐标的矩阵)view=M−1.

            首先。我们要清楚将世界坐标系坐标系平移到相机坐标系的目的是将它们放到同一线性空间下。上面已经提到过这是进行坐标的基础。平移的部分前面的博客已经介绍过。

           我们写出平移矩阵:

      

            接下来,我们要求旋转矩阵,利用基变换和坐标变换进行求解。我们在此求的是将摄像机坐标系下变换到世界坐标系中坐标的变换矩阵。

            此时对于摄像机坐标系中的一个点P(X, Y, Z),求在世界坐标系中的点p(x, y, z),则:p=P * (U, V, N) 即

                    X = X * Ux + Y * Uy + Z * Uz;

                    Y = X * Vx + Y * Vy + Z * Vz;

                    Z = X * Nx + Y *Ny + Z * Nz;

            此时我们可以得到一个坐标基矩阵,(其实我们此时可以对旋转有了更深层次的理解,旋转其实可以理解为基变换)就是上面求得的side、up、forward基向量构成的矩阵,写成4×4的矩阵:

     

          那么所求的矩阵view计算过程如下:

            在计算过程中,使用到了旋转矩阵的性质,即旋转矩阵是正交矩阵,它的逆矩阵等于矩阵的转置。因此所求的:

    五、案例demo

    接下来我们看一个具体案例demo,此处为摄像机旋转观察立方体(按A键即可):

    效果图:

    着色器:

     var VertexShader='#version 300 es \n' +
            'uniform mat4 uMVPMatrix; \n ' +                    //总变换矩阵
            ' in vec3 aPosition; \n' +                          //顶点位置
            '  in vec4 aColor; \n' +                            //顶点颜色
            'out vec4 aaColor;\n' +                             //传递给片元着色器的变量
            'void main(){\n' +
            'gl_Position=uMVPMatrix * vec4(aPosition,1);\n' +
            'aaColor=aColor;\n' +
            '}\n';
     var FragmentShader='#version 300 es \n' +
            'precision mediump float; \n' +
            'in vec4 aaColor; \n' +                 //接受顶点着色器的值
            'out vec4 fragColor; \n' +              //输出到片元的颜色
            'void main(){ \n' +
            'fragColor=aaColor;\n' +                //给此片元的颜色值
            '}\n';

     

    初始化方法:

     

    function start() {
            var canvas = document.getElementById("webglcanvas");
            gl = canvas.getContext('webgl2', { antialias: true });
            if (!gl){                                          //若获取GL上下文失败
                alert("创建GLES上下文失败,不支持webGL2.0!");    //显示错误提示信息
                return;
            }
            //链接着色器
            initShader(gl);
            //绑定数据
            var n = bindDataBuffer(gl);
            //设置视口
            gl.viewport(0,0,canvas.width, canvas.height);
            gl.enable(gl.DEPTH_TEST);
            //初始化相机坐标
            g_eyeX=0.4*Math.cos(angle);
            g_eyeZ=0.4*Math.sin(angle);
            //主绘制方法
            draw(gl,n);
            //dom监听
            document.onkeydown = function (event) {
                if(event.key === 'a') {
                    angle+=0.01;
                    g_eyeX=0.4*Math.cos(angle);
                    g_eyeZ=0.4*Math.sin(angle);
                    console.log(angle)
                    draw(gl,n);
                }
            }
        }

     

    绘制方法:

     

     //主绘制方法
        function draw(gl,n) {
            var cameraMatrix=multiMatrix44(getOrthoProjection(-1.0,1.0,-1.0,1.0,-1.0,1.0),setcamera(g_eyeX,0.4,g_eyeZ,0,0,0,0,1,0));
            console.log(getOrthoProjection(-1.0,1.0,-1.0,1.0,-1.0,1.0))
            var uMVPMatrix=gl.getUniformLocation(gl.program,"uMVPMatrix");
            gl.uniformMatrix4fv(uMVPMatrix,false,new Float32Array(cameraMatrix));
    
            var a_Position=gl.getAttribLocation(gl.program,"aPosition");
            gl.enableVertexAttribArray(a_Position);
            gl.bindBuffer(gl.ARRAY_BUFFER, vertexBuffer);
            gl.vertexAttribPointer(a_Position,3,gl.FLOAT,false,0,0);
    
            var a_Color=gl.getAttribLocation(gl.program,"aColor");
            gl.enableVertexAttribArray(a_Color);
            gl.bindBuffer(gl.ARRAY_BUFFER,colorBuffer);
            gl.vertexAttribPointer(a_Color,4,gl.FLOAT,false,0,0);
    
            gl.clearColor(0.0, 0.0, 0.0, 1.0);// 指定清空canvas的颜色
            gl.clear(gl.COLOR_BUFFER_BIT );
            gl.drawArrays(gl.TRIANGLES, 0, n);
        }

    设置摄像机

     function setcamera(eyeX,eyeY,eyeZ,targetX,targetY,targetZ,upX,upY,upZ) {
            //求向量空间下的基(摄像机)
            var zAxis=subVector([targetX,targetY,targetZ],[eyeX,eyeY,eyeZ]);
            var N=normalizeVector(zAxis);
    
            var xAxis=crossMultiVector(N,[upX,upY,upZ]);
            var U=normalizeVector(xAxis);
    
            var V=crossMultiVector(U,N);
            //旋转矩阵(线性变换部分为基变换公式中的过度矩阵)
            var R=[
                U[0],V[0],-N[0],0,
                U[1],V[1],-N[1],0,
                U[2],V[2],-N[2],0,
                0,0,0,1
            ]
            //平移矩阵(实际上是将两个坐标系变换到同一个向量空间下)
            var T=translation(-eyeX,-eyeY,-eyeZ);
            console.log("摄像机"+multiMatrix44(R,T))
            return multiMatrix44(R,T);
        }

    向量计算以及矩阵计算:

     /**向量及矩阵运算**/
        //向量减法
        function subVector(v1,v2) {
            return[v1[0]-v2[0],v1[1]-v2[1],v1[2]-v2[2]];
        }
        //向量加法
        function addVector(v1,v2) {
            return[v1[0]+v2[0],v1[1]+v2[1],v1[2]+v2[2]];
        }
        //向量归一化
        function normalizeVector(v) {
            var len=Math.sqrt(v[0]*v[0]+v[1]*v[1]+v[2]*v[2]);
            return (len>0.00001)? [v[0]/len,v[1]/len,v[2]/len]:[0,0,0];
        }
        //向量叉乘
        function crossMultiVector(v1,v2) {
            return[
                v1[1]*v2[2]-v1[2]*v2[1],
                v1[2]*v2[0]-v1[0]*v2[2],
                v1[0]*v2[1]-v1[1]*v2[0]
            ]
        }
        //向量点乘
        function dotMultiVector(v1, v2) {
            var res = 0;
            for (var i = 0; i < v1.length; i++) {
                res += v1[i] * v2[i];
            }
            return res;
        }
        //矩阵转置
        function transposeMatrix(mat) {
            var res = new Float32Array(16);
            for (var i = 0; i < 4; i++) {
                for (var j = 0; j < 4; j++) {
                    res[i * 4 + j] = mat[j * 4 + i];
                }
            }
            return res;
        }
        //4 x 4 矩阵乘法
        function multiMatrix44(m1, m2) {
            var mat1 = transposeMatrix(m1);
            var mat2 = transposeMatrix(m2);
    
            var res = new Float32Array(16);
            for (var i = 0; i < 4; i++) {
                var row = [mat1[i * 4], mat1[i * 4 + 1], mat1[i * 4 + 2], mat1[i * 4 + 3]];
                for (var j = 0; j < 4; j++) {
                    var col = [mat2[j], mat2[j + 4], mat2[j + 8], mat2[j + 12]];
                    res[i * 4 + j] = dotMultiVector(row, col);
                }
            }
            return transposeMatrix(res);
        }

        细心的朋友可以发现,我用正交投影矩阵乘了摄像机矩阵之后,传入到着色器中去的,如果不设置投影矩阵会出现很大的问题,这个我会在后面阐述。

        代码知识简要贴出一部分,其余代码是链接着色器程序,检测着色器编译状态以及创建缓冲(绑定顶点和颜色数据)等,这些并不是本博客探究的重点,我贴出了向量及矩阵计算的部分,这是产生摄像机矩阵的重点,大家可以自行将代码粘贴下来进行尝试。

        demo下载:https://download.csdn.net/download/weixin_37683659/10329752

    六、总结

       由于水平有限,写的不好,大家多交流。这些东西需要一定的数学基础和计算机图形学的基础。这里推荐两本书,《交互式计算机图形学 基於OpenGL着色器的自顶向下方法(第6版)》(美Edward Angel等编著)【电子工业出版社】》和《工程数学线性代数第六版》。

     

     

          

    展开全文
  • 散点矩阵图(也称SPLOM,或Scatterplot Matrix)用于粗略展现N列数据中,不同列之间的关系,可以粗略估计哪些变量是正相关的,哪些是负相关的,进而为下一步数据分析提供决策。许多统计语言里面都有非常方便的函数...
    散点矩阵图(也称SPLOM,或Scatterplot Matrix)用于粗略展现N列数据中,不同列之间的关系,可以粗略估计哪些变量是正相关的,哪些是负相关的,进而为下一步数据分析提供决策。许多统计语言里面都有非常方便的函数生成散点矩阵图,比如说R。那么Python语言有没有呢?答案还是seaborn图形库。
      其实seaborn库生成的散点矩阵图不是常规的散点矩阵图,其斜对角标注的不是列名,而是该列的概率密度分布图。这倒无妨,我们依然可以通过整个矩阵图进行分析判断。我们来看代码:
    import seaborn as sns

    iris = sns.load_dataset("iris")  # 这里的iris不是某个文件,而是seaborn自带的展示用数据集
    sns.pairplot(iris);
    sns.plt.show()

    初学pandas与seaborn(六)制作散点图矩阵,用python


    如果数据量特别大,那么全部用散点表示会非常卡。我们应该用等高线表示,这样不会那么窘迫:
    import seaborn as sns

    iris = sns.load_dataset("iris")  # 这里的iris不是某个文件,而是seaborn自带的展示用数据集

    g = sns.PairGrid(iris)
    g.map_diag(sns.kdeplot)
    g.map_offdiag(sns.kdeplot, cmap="Blues_d", n_levels=6);
    sns.plt.show()
    初学pandas与seaborn(六)制作散点图矩阵,用python


    当需要从外部导入数据的时候,我们用pandas来导入:
    # encoding:utf-8
    import seaborn as sns
    import pandas as pd

    tips = pd.read_csv("winequality-white.txt")
    # tips2 = tips[[0, 1, 2, 5]]  # 选取其中个别列来表示散点矩阵图

    g = sns.PairGrid(tips)
    g.map_diag(sns.kdeplot)
    g.map_offdiag(sns.kdeplot, cmap="Blues_d", n_levels=3)
    sns.plt.show()

    初学pandas与seaborn(六)制作散点图矩阵,用python


    如何快速创建强大的可视化探索性数据分析,这对于现在的商业社会来说,变得至关重要。今天我们就来,谈一谈如何使用python来进行数据的可视化!

    一旦你有了一个很好的被清理过的数据集,下一步就是探索性数据分析(EDA)。EDA是确定数据可以告诉我们的过程,我们使用EDA来查找模式、关系或异常情况,以便指导我们后续的工作。然而在EDA中有很多的方法,但最有效的工具之一是对图(也称为散点图矩阵)。散点图矩阵让我们看到了两个变量之间的关系。散点图矩阵是识别后续分析趋势的好方法,幸运的是,它们很容易用Python实现!

    在本文中,我们将通过使用seaborn可视化库在Python中进行对图的绘制和运行。我们将看到如何创建默认配对图以快速检查我们的数据,以及如何自定义可视化以获取更深入的洞察力。该项目的代码在GitHub上以Jupyter Notebook的形式提供。在这个项目中,我们将探索一个真实世界的数据集,由GapMinder收集的国家级社会经济数据组成。

    Seaborn的散点图矩阵(Pairs Plots)

    在开始之前,我们需要知道我们有什么数据。我们可以将社会经济数据用熊猫(Pandas)数据框加载并查看列:

    每行数据代表一个国家在一年内的结果,列中包含变量(这种格式的数据称为整洁数据)。有2个分类专栏(国家和大陆)和4个数字专栏。这些专栏包括:life_exp是几年出生时的预期寿命,pop是人口,gdp_per_cap是以国际美元为单位的人均国内生产总值。

    虽然后面我们将使用分类变量进行着色,但seaborn中的默认对图仅绘制了数字列。创建默认的散点图矩阵很简单:我们加载到seaborn库并调用pairplot函数,将它传递给我们的数据框:

    我仍然惊讶于一行简单的代码就可以完成我们整个需求!散点图矩阵建立在两个基本图形上,直方图和散点图。对角线上的直方图允许我们看到单个变量的分布,而上下三角形上的散点图显示了两个变量之间的关系。例如,第二行中最左边的图表显示life_exp与年份的散点图。

    默认的散点图矩阵图经常给我们提供有价值的见解。我们看到人均预期寿命和人均GDP是正相关的,这表明高收入国家的人们倾向于更长寿(尽管这当然不能证明导致其他人也是如此)。它也似乎看起来是全世界的预期寿命随着时间的推移而上升。为了在未来的图中更好地显示这些变量,我们可以通过取这些值的对数来转换这些列:

    虽然这种制图本身可以用于分析,但我们可以发现,通过对诸如大陆这样的分类变量进行数字着色,使其更有价值。这在seaborn中非常简单!我们所需要做的就是在hue中使用sns.pairplot函数调用使用关键字:

    现在我们看到大洋洲和欧洲的人均预期寿命最高,亚洲人口最多。请注意,我们对人口和gdp的日志转换使这些变量正态分布,从而更全面地表示值。

    上图更具信息性,但仍然存在一些问题:找不到叠加的直方图,就像在对角线上那样,它非常易于理解。显示来自多个类别的单变量分布的更好方法是密度图。我们可以在函数调用中交换柱状图的密度图。当我们处理它时,我们会将一些关键字传递给散点图,以更改点的透明度,大小和边缘颜色。

    对角线上的密度图比堆积条更容易比较各大洲之间的分布。改变散点图的透明度可以提高可读性,因为这些数字有相当多的重叠(称为重叠绘图)。

    作为pairplot默认的最后一个例子,让我们通过绘制2000年后的年份来减少数据混乱。我们仍然会按照大陆分布着色,但现在我们不会绘制年份列。为了限制绘制的列,我们将一个列表传递vars给函数。为了说明情节,我们还可以添加标题。

    这开始看起来很不错!如果我们要进行建模,我们可以使用这些图中的信息来帮助我们进行选择。例如,我们知道log_gdp_per_cap与life_exp正相关,所以我们可以创建一个线性模型来量化这种关系。对于这篇文章,我们将坚持绘图,如果我们想要更多地探索我们的数据,我们可以使用PairGrid类自定义散点图矩阵。

    使用PairGrid进行自定义

    与sns.pairplot函数相反,sns.PairGrid是一个类,它意味着它不会自动填充我们的网格plot。相反,我们创建一个类实例,然后将特定函数映射到网格的不同部分。要用我们的数据创建一个PairGrid实例,我们使用下面的代码,这也限制了我们将显示的变量:

    如果我们要显示它,我们会得到一个空白图,因为我们没有将任何函数映射到网格部分。有三个网格部分填写PairGrid:上三角形、下三角形和对角线。要将网格映射到这些部分,我们使用grid.map 部分中的方法。例如,要将散点图映射到我们使用的上三角形:

    该map_upper方法接受任何两个变量数组(如plt.scatter)和关联的关键字(如color)的函数。该map_lower方法完全相同,但填充网格的下三角形。因为它需要在接受单个阵列(记住对角线仅示出了一个变量)的函数略有不同。一个例子是plt.hist我们用来填写下面的对角线部分:

    在这种情况下,我们在下三角形中使用2-D(密度图)的核密度估计值。放在一起,这段代码给了我们下面的图:

    使用PairGrid类的真正好处在于我们想要创建自定义函数来将不同的信息映射到图上。例如,我可能想要将两个变量之间的Pearson相关系数添加到散点图中。为此,我会编写一个函数,它接受两个数组、计算统计量,然后在图上绘制它。下面的代码显示了这是如何完成的(归功于这个Stack Overflow答案):

    我们的新函数映射到上三角形,因为我们需要两个数组来计算相关系数(还要注意我们可以将多个函数映射到网格部分)。这会产生以下图形:

    相关系数现在出现在散点图上方。这是一个相对直接的例子,但我们可以使用PairGrid将我们想要的任何函数映射到图上。我们可以根据需要添加尽可能多的信息,只要我们能够弄清楚如何编写函数!作为最后一个例子,这里是一个显示对角线而不是网格的汇总统计图。

    它显示了我们只做图标的总体思路,除了使用库中的任何现有功能(例如matplotlib将数据映射到图上)之外,我们还可以编写自己的函数来显示自定义信息。

    结论

    散点图矩阵是快速探索数据集中的分布和关系的强大工具。Seaborn提供了一个简单的默认方法,可以通过Pair Grid类来定制和扩展散点图矩阵。在一个数据分析项目中,价值的主要部分往往不在于浮华的机器学习,而在于直观的数据可视化。散点图举证为我们提供了全面的数据分析,是数据分析项目的一个很好的起点。

    数十款阿里云产品限时折扣中,赶紧点击领劵开始云上实践吧!

    本文由阿里云云栖社区组织翻译。

    文章原标题《visualizing-data-with-pair-plots-in-python》,



    展开全文
  • 图像就是矩阵

    万次阅读 多人点赞 2017-12-23 22:27:19
    矩阵有着行(row)和列(column),矩阵的操作在数学和计算机中的处理都很常见且成熟,于是很自然的就把图像作为一个矩阵,把对图像的操作转换成对矩阵的操作,实际上所有的图像处理工具都是这么做的。我们看看...

    学过线性代数的对矩阵并不陌生。一般来说,图像是一个标准的矩形,有着宽度(width)和高度(height)。而矩阵有着行(row)和列(column),矩阵的操作在数学和计算机中的处理都很常见且成熟,于是很自然的就把图像作为一个矩阵,把对图像的操作转换成对矩阵的操作,实际上所有的图像处理工具都是这么做的。

    我们看看下面这张图像:

    这里写图片描述

    用opencv读取:

    import cv2
    mountain = cv2.imread('mountain.bmp', 0) # 读取为灰度图
    print("shape=", mountain.shape)
    print("type=", type(mountain))

    输出结果:

    type= <class 'numpy.ndarray'>
    shape= (480, 640)

    可以看出,图像在读取后,存在了一个ndarray中,这是numpy中的矩阵类型。

    源图像的宽度是640,高度是480,我们一般习惯上依次用高度、宽度的顺序。在矩阵中,高度对应的是多少行(row),宽度对应的是多少列(column),而矩阵的顺序是(row,column),所以输出的shape是(480, 640)。

    把图像作为矩阵,可以很方便的进行一些操作,例如取图像中某个区域的值,也就是所谓的crop(裁剪)操作。

    print(mountain[9:12, 9:12])

    输出结果:

    [[244 244 244]
     [244 236 244]
     [244 244 236]]

    取大一些的区域,并显示出来。

    cv2.imshow("crop", mountain[200:400, 200:600])
    print(mountain[200:400, 200:600].shape)
    cv2.waitKey()

    输出结果:
    这里写图片描述

    (200, 400)

    对于如下的彩色图像:
    这里写图片描述

    fruits = cv2.imread('fruits.bmp')
    print("type=", type(fruits))
    print("shape=", fruits.shape)
    print(fruits[100, 100])

    输出结果:

    type= <class 'numpy.ndarray'>
    shape= (480, 512, 3)
    [ 52  96 116]

    可以看出,彩色图像同样是一个矩阵,只是矩阵中的每一个点不是一个值,而是包含3个值的数组,这3个值就是RGB值,下面的代码查看RGB3通道的图像(注意,opencv的顺序是BGR)。

    import matplotlib.pyplot as plt
    fruits = cv2.cvtColor(fruits, cv2.COLOR_BGR2RGB)
    fruits_all = [fruits, fruits[:, :, 0], fruits[:, :, 1], fruits[:, :, 2]]
    channels = ["RGB", "red", "green", "blue"]
    for i in range(4):
        plt.subplot(2, 2, i + 1)
        plt.imshow(fruits_all[i], cmap=plt.cm.gray)
        plt.title(channels[i])
    plt.show()
    for fruit in fruits_all:
        print(fruit.shape)

    这里写图片描述

    (480, 512, 3)
    (480, 512)
    (480, 512)
    (480, 512)

    可以看出,每一个RGB通道都是一个矩阵。这3个RGB通道叠在一起形成了彩色图像。

    你还可以方便的得到某一行图像的值。

    fruit_red = fruits[:, :, 0]
    plt.plot(fruit_red[200, :])
    plt.show()

    输出结果:

    这里写图片描述

    那么,到底是把图像看作函数,还是看作矩阵?都可以,看你要干什么了,2个不同的角度而已。

    展开全文
  • 散点图矩阵

    千次阅读 2018-04-14 19:43:07
    &gt; install.packages('GGally') &gt; library(GGally) &gt; theme_set(theme_minimal(20)) #设置主题 &gt; set.seed(1836) &gt; pf_subset &lt;- pf[,c(2,15)] &...
    > install.packages('GGally')
    > library(GGally)
    > theme_set(theme_minimal(20))   #设置主题
    > set.seed(1836)
    > pf_subset <- pf[,c(2,15)]
    > names(pf_subset)
    [1] "age"                "www_likes_received"
    > pf_subset <- pf[,c(2:15)]
    > names(pf_subset)
     [1] "age"                   "dob_day"               "dob_year"              "dob_month"            
     [5] "gender"                "tenure"                "friend_count"          "friendships_initiated"
     [9] "likes"                 "likes_received"        "mobile_likes"          "mobile_likes_received"
    [13] "www_likes"             "www_likes_received"   
    > ggpairs(pf_subset[sample.int(nrow(pf_subset),1000),])
     plot: [5,1] [===========================-----------------------------------------------------------------] 29% est:12s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [5,2] [===========================-----------------------------------------------------------------] 30% est:13s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [5,3] [============================----------------------------------------------------------------] 30% est:13s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [5,4] [============================----------------------------------------------------------------] 31% est:13s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [6,5] [===================================---------------------------------------------------------] 38% est:12s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [7,5] [==========================================--------------------------------------------------] 45% est:10s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [8,5] [================================================--------------------------------------------] 53% est: 9s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [9,5] [=======================================================-------------------------------------] 60% est: 7s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [10,5] [=============================================================------------------------------] 67% est: 6s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [11,5] [===================================================================------------------------] 74% est: 5s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [12,5] [==========================================================================-----------------] 81% est: 3s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [13,5] [================================================================================-----------] 88% est: 2s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
     plot: [14,5] [=======================================================================================----] 95% est: 1s `stat_bin()` using `bins = 30`. Pick better value with `binwidth`.
    Warning messages:                                                                                                       
    1: Removed 2 rows containing non-finite values (stat_boxplot). 
    2: Removed 2 rows containing non-finite values (stat_boxplot). 
    3: Removed 2 rows containing non-finite values (stat_boxplot). 
    4: Removed 2 rows containing non-finite values (stat_boxplot). 
    5: Removed 2 rows containing non-finite values (stat_boxplot). 
    6: Removed 2 rows containing non-finite values (stat_boxplot). 
    7: Removed 2 rows containing non-finite values (stat_boxplot). 
    8: Removed 2 rows containing non-finite values (stat_boxplot). 
    9: Removed 2 rows containing non-finite values (stat_boxplot).

    这里写图片描述
    你可能还会发现:变量标签是在散点图矩阵的外边缘上,而非对角线上。如果你希望标签在对角线上,你可以在 ggpairs 命令中设置 axisLabels = ‘internal’ 参数。
    当出现大量变量的时候,用图形矩阵会很方便。

    创造热图

    nci <- read.table("nci.tsv.crdownload")
    colnames(nci) <- c(1:64)

    R 中的融合数据框

    nci <- read.table("nci.tsv.crdownload")
    colnames(nci) <- c(1:64)
    library(reshape2)
    nci.long.samp <- melt(as.matrix(nci[1:200,]))
    names(nci.long.samp) <- c('gene','case','value')
    head(nci.long.samp)
    
    ggplot(aes(y=gene,x=case,fill=value),data=nci.long.samp)+
      geom_tile()+
      scale_fill_gradientn(colours=colorRampPalette(c('blue','red'))(100))

    这里写图片描述

    展开全文
  • 两张图像矩阵的距离

    2020-10-09 17:38:56
    矩阵范数 转载:下面这篇博客写的很详细。 https://blog.csdn.net/pipisorry/article/details/51030563
  • 图像旋转算法原理-- 旋转矩阵

    万次阅读 多人点赞 2011-09-05 19:58:19
    1     2     3      4      5      6     7     8
  • 分块矩阵的逆矩阵的公式记忆方法

    万次阅读 2016-07-16 12:54:28
    然后,我们可以像在行列式中对行列式分为主对角线行列式和副对角线行列式一样,把这些分块矩阵分为两类:主对角线分块矩阵中1,4,5)和副对角线分块矩阵中2,3,6)。 我们先来看主对角线分块矩阵的逆...
  • 像素值矩阵变为图片

    千次阅读 2018-08-31 21:56:14
    在MATLAB上,导入矩阵数据,数据命名a 然后执行以下代码:imshow(a); 或imwrite(mat2gray(matrix), 'matrix.tif');
  • 读取图片矩阵import matplotlib im = matplotlib.image.imread('0_0.jpg')保存矩阵图片import numpy as np import scipyx = np.random.random((600,800,3)) scipy.misc.imsave('meelo.jpg', x)
  • 版权声明:本文为博主原创文章,转载请在您的文章开始注明原址:https://blog.csdn.net/Broccoli_Lian/article/details/79755225学习CV第六天
  • 写论文的过程中经常需要画一个混淆矩阵(confusion matrix)来验证分类结果的有效性。通常只需要两个步骤: - 保存混淆矩阵文本文件 ...>> imagesc(ans)即可得到混淆矩阵图,可以添加Colorbarshipyar使图片更加好看。
  • 【图论】拉普拉斯矩阵(Laplacian matrix)

    万次阅读 多人点赞 2018-10-22 12:17:11
    拉普拉斯矩阵是图论中用到的一种重要矩阵,给定一个有n个顶点的 G=(V,E),其拉普拉斯矩阵被定义为 L = D-A,D其中为的度矩阵,A为的邻接矩阵。例如,给定一个简单的: 把此“”转换为邻接矩阵的形式,...
  • 本文介绍了一些图论的基础知识,包括的表示、邻接矩阵、度矩阵等(边不带权值的情况),本文中某些图片或者知识的参考/来源已列于本文最后。 (graph)       用G=(V, E)表示,V中元素为...
  • 数学中的各种矩阵大总结

    万次阅读 多人点赞 2017-07-23 02:09:21
    很多特殊矩阵,常常令人眼花缭乱,例如:Toeplitz 矩阵、Hermitian 矩阵、Circulant 矩阵、Unitary 矩阵、Hessian 矩阵、Vandermonde 矩阵和Fourier矩阵等。本文将一一解析这些特殊矩阵,并在最后讨论循环矩阵的...
  • from PIL import Image new_im = Image.fromarray(data) #data二维图片矩阵。 new_im.show()
  • matlab 矩阵转化成彩色图像显示

    万次阅读 2011-07-28 11:38:36
    用imshow如果只是n*n的图像那么就生成灰度图像之后直接用colormap(jet)可以转换为彩色的,但是这个颜色变化范围要确定简单的直接用imagesc(mat),就能够直接根据矩阵的最小值和最大值生成彩色图像
  • 邻接矩阵与关联矩阵

    千次阅读 2018-08-30 18:56:12
    https://blog.csdn.net/Hanging_Gardens/article/details/55670356
  • 线性代数:矩阵运算之乘法?

    万次阅读 2019-05-04 13:00:00
    线性代数:矩阵运算之乘法? 分步阅读 授人予鱼不如授人予渔,在《线性代数》的学习中,方法尤为重要。下面就让我们一起解决《线性代数》中令人头痛的——矩阵的乘法运算吧! 如果您对——矩阵乘法的学习比较吃力...
  • 1、图像转换为矩阵matrix = numpy.asarray(image) 2、矩阵转换为图像image = Image.fromarray(matrix)
  • 这个问题是在看Fast Gaussian Blur ...首先遇到的问题就是如何将一副图片转换为矩阵的形式。下为在群里得到的答案: 总结起来,有很多的库可以作为读取图片文件并将其转换为矩阵的形式来使用。 [1]imagemagi
1 2 3 4 5 ... 20
收藏数 425,636
精华内容 170,254
关键字:

图矩阵