matrix_matrixxd - CSDN
精华内容
参与话题
  • Matrix使用解析

    千次阅读 2016-10-24 14:08:07
    Matrix的使用范围非常广泛,我们平时使用的Tween Animation,其在进行位移、缩放、旋转时,都是通过Matrix来实现的。除此之外,在进行图像变换操作时,Matrix也是最佳选择。 Matrix是一个3*3的矩阵,如图所示: ...

    Matrix的使用范围非常广泛,我们平时使用的Tween Animation,其在进行位移、缩放、旋转时,都是通过Matrix来实现的。除此之外,在进行图像变换操作时,Matrix也是最佳选择。

    Matrix是一个3*3的矩阵,如图所示:


    我们可以直接通过Matrix.getValues方法获取Matrix的矩阵值(浮点型数组类型),然后修改矩阵值(Matrix类为每一个矩阵值提供了固定索引,如:MSCALE_X、MSKEW_X等),最后通过Matrix.setValues方法重新设置Matrix值,已达到修改Matrix的目的。这种方式要求我们对Matrix每一个值的作用都要十分了解,操作起来比较繁琐,但却是最灵活、最彻底的操作方式。

    具体要修改哪些Matrix值,则取决于要实现什么效果,从本质上这是一个数学问题,这里给出几种比较常见的方案:

    1. 实现Translate操作
      位移操作在Matrix中对应是MTRANS_XMTRANS_Y值,分别表示X和Y轴上的位移量,假设在X和Y轴上分别位移100px,那么对应的Matrix就是


    2.实现Scale操作
    缩放操作在Matrix中对应的是MSCALE_XMSCALE_Y值,分别表示X和Y轴上的缩放比例,假设在X和Y轴上分别放大2倍,那么对应的Matrix就是


    3.实现Rotate操作
    旋转操作在Matrix中对应是MSCALE_XMSCALE_YMSKEW_XMSKEW_Y值,假设我们要以坐标原点为中心,旋转A度,那么对应的Matrix就是


    4.实现Skew操作
    错切操作在Matrix中对应的是MSKEW_XMSKEW_Y,分别表示X和Y轴上的错切系数,假设在X轴上错切系数为0.5,Y轴上为2,那么对应的Matrix就是

    其他3种操作都比较常见,但是错切操作我们可能不是很熟悉。

    错切可分为水平错切和垂直错切。
    水平错切表示变换后,Y坐标不变,X坐标则按比例发生平移,且平移的大小和Y坐标成正比,即新的坐标为(X+Matrix[MSKEW_X] * Y,Y)
    垂直错切表示变换后,X坐标不变,Y坐标则按比例发生平移,且平移的大小和X坐标成正比,即新的坐标为(X,Y+Matrix[MSKEW_Y] * X)
    当然,我们也可以同时实现水平错切和垂直错切。

    关于为什么修改Matrix的这些值后,就实现了位移、缩放、旋转和错切操作,就主要是数学推导过程了,可以参考这篇文章—— Android中图像变换Matrix的原理,讲解的非常详细,强烈推荐。


    除了可以直接修改Matrix值,Matrix类还提供了一些API来操作Matrix。这里主要介绍几类比较常用的API。

    setXXXpreXXXpostXXX

    XXX可以是Translate、Rotate、Scale、Skew和Concat(表示直接操作Matrix矩阵)。我们主要搞清楚这3种API的区别就OK了。

    1. setXXX,首先会将该Matrix设置为单位矩阵,即相当于调用reset()方法,然后再设置该Matrix的值。
    2. preXXX,不会重置Matrix,而是被当前Matrix左乘(矩阵运算中,A左乘B等于A B),即M’ = M S(XXX)。
    3. postXXX,不会重置Matrix,而是被当前Matrix右乘(矩阵运算中,A右乘B等于B A),即M’ = S(XXX) M。

    当这些API同时使用时,又会出现什么效果那,我们来看个例子:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    
    Matrix matrix = new Matrix();
    float[] points = new float[] { 10.0f, 10.0f };
    matrix.postScale(2.0f, 3.0f);// 第1步
    matrix.preRotate(90);// 第2步
    matrix.setScale(2f, 3f);// 第3步
    matrix.preTranslate(8.0f, 7.0f);// 第5步
    matrix.postTranslate(18.0f, 17.0f);// 第4步
    matrix.mapPoints(points);
    Log.i("test", points[0] + " : " + points[1]);
    

    最后得到的结果是:54.0 : 68.0
    可以发现,在第3步setScale之前的第1、2步根本就没有用,直接被第3步setScale覆盖了。所以最终的矩阵运算为

    Translate(18,17) * Scale(2,3) * Translate(8,7) * (10,10)

    这样,就很容易得出最后的结果了。

    这里也许会有一个疑问,为什么坐标点(10,10)会被结果矩阵(矩阵运算虽然不满足交换律,但是满足结合律)左乘,而不是右乘。这一点我们看一下下面的矩阵运算就会明白。
    Matrix相乘
    等号左边是变换后的坐标点,等号右边是Matrix矩阵左乘原始坐标点。因为Matrix是3行3列,坐标点是3行1列,所以正好可以相乘,但如果反过来,就不满足矩阵相乘的条件了(左边矩阵的列数等于右边矩阵的行数)。所以,就可以理解为什么是结果矩阵左乘原始坐标点了。

    等号左边是变换后的坐标点,等号右边是Matrix矩阵左乘原始坐标点。因为Matrix是3行3列,坐标点是3行1列,所以正好可以相乘,但如果反过来,就不满足矩阵相乘的条件了(左边矩阵的列数等于右边矩阵的行数)。所以,就可以理解为什么是结果矩阵左乘原始坐标点了。

    也正因为这一点以及矩阵的结合律,所以我们可以理解上面矩阵运算的流程:

    先对原始坐标点(10,10)进行Translate(8,7)位移,然后再对中间坐标点(18,17)进行Scale(2,3)放大,最后再次对中间坐标点(36,51)进行Translate(18,17)操作,就得到了最后的坐标点(54,68)

    这里还有一个小Tips
    当需要对Matrix矩阵进行比较复杂的设置时,可以把这些复杂的设置,拆分为多个步骤,每一个步骤都是一个简单的Matrix,然后再依据这些步骤的先后顺序,决定是通过左乘 or 右乘得到结果矩阵,最后通过结果矩阵左乘原始坐标就OK了(设计时,可以拆分之后理解,但最终运算时还是要得到一个结果矩阵,再去操作原始坐标)。

    还有一点需要了解:Canvas里的scale、translate、rotate和concat都是preXXX方法,如果要进行更多的变换可以先从Canvas获得Matrix, 变换后再设置回Canvas. 但是这里有个坑,最后会进行介绍点击这里跳转

    mapPoints mapRect mapVectors

    这些API很简单,主要是根据当前Matrix矩阵对点、矩形区域和向量进行变换,以得到变换后的点、矩形区域和向量。经常和下面的invert方法结合使用。

    invert

    通过上面的mapXXX方法,可以获取变换后的坐标或者矩形。但假设我们知道了变换后的坐标,如何计算Matrix变换前的坐标那?!
    此时通过invert方法获取的逆矩阵就派上用场了。所谓逆矩阵,就是Matrix旋转了30度,逆Matrix就反向旋转30度,Matrix放大n倍,逆Matrix就缩小n倍。假设逆矩阵是invertMatrix,那么Matrix.preConcat(invertMatrix) 和 Matrix.postConcat(invertMatrix) 都应该等于单位矩阵(但实际上会有一些误差)。
    所以,通过Matrix和invertMatrix对坐标进行变换的规则可总结如下:
    通过Matrix和invertMatrix对坐标进行变换的规则

    逆矩阵在进行自定义View Touch事件处理时很有用,假设我们在自定义View中,通过Matrix(包含了旋转、缩放和位移操作)绘制了Bitmap,现在想要判断Touch事件是否在变换后的Bitmap范围内,应该如何操作那?!

    首先想到的可能是下面的方案:

    1
    2
    3
    4
    
    RectF rect = new RectF(bitmap.getWidth(),bitmap.getHeight());
    //假设matrix就是对bitmap进行变换的矩阵
    matrix.mapRect(rect);
    boolean isTouchBitmap = rect.contains(touchX,touchY);
    

    但是这种方式实际上不是非常的准确,通过matrix变换后的矩形区域并不是真实的Bitmap区域,而是包含bitmap的矩形区域(很难描述啊),看下图就知道了:



    Matrix正向操作

    图中的绿色矩形区域就是我们进行判断的rect区域,很明显误差很大哈。既然正向操作不可行,那就只能试下逆向操作了:

    1
    2
    3
    4
    5
    
    RectF rect = new RectF(bitmap.getWidth(),bitmap.getHeight());
    float eventFloat[] = new float[]{touchX,touchY};
    //假设invertMatrix是matrix的逆矩阵,这里对Touch坐标进行逆向操作。
    invertMatrix.mapPoints(eventFloat);
    boolean isTouchBitmap = rect.contains(eventFloat[0],eventFloat[1]);
    

    通过这种方式,首先会对Touch坐标进行逆矩阵操作,然后再判断是否落在原始bitmap矩形区域内(上图中的小企鹅),就比较精确了。精妙哈!!!


    Canvas.getMatrix的坑

    通过Canvas获取Matrix矩阵的拷贝,从API16开始,不再推荐使用。至于原因,可参考Google的解释Issue 24517: Canvas getMatrix/setMatrix with hardware acceleration bug,里面提供了示例代码。

    主要原因是,在开启硬件加速的情况下Canvas.getMatrix 获取的矩阵是相对于Canvas所属View的,而Canvas.setMatrix 则会把所设置的矩阵当做相对于整个屏幕(包括系统栏)。

    所谓相对于某个View,就是说不管这个View在屏幕中的任何位置,通过这个View的Canvas获取的Matrix的X和Y位移都是0,也就是Matrix在当前View的本地坐标系中,和View的left和top值无关。

    所谓相对于整个屏幕,也就很好理解了,即获取的Matrix是在整个屏幕表示的世界坐标系中的,一般情况下,获取的矩阵的X位移为view.left值,Y位移为系统栏的高度 + view.top值。并且后续对Canvas的变换操作都是基于这个初始矩阵进行的。

    所以在硬件加速的情况下,调用canvas.setMatrix(canvas.getMatrix())后,就会导致View默认从屏幕左上角(包含了系统栏)开始绘制,这样就会有一部分内容被系统栏遮挡住。
    这里对Google提供的示例代码进行了简化,就是把一个自定义View添加到带有系统栏的Activity中,自定义View的onDraw方法如下所示:


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    
    protected void onDraw(Canvas canvas) {
       canvas.save(Canvas.MATRIX_SAVE_FLAG);
       Matrix matrix = canvas.getMatrix();
       //查看获取的初始Matrix
       Log.i("matrix",matrix.toString());
       // This line changes the canvas' transformation when hardware acceleration is turned on (but shouldn't)
       canvas.setMatrix(matrix);
            
       mPaint.setColor(Color.GREEN);
       //draw一个200*200的矩形区域
       canvas.drawRect(0, 0, 200, 200, mPaint);
       canvas.restore();
    
       // here the bottom right corner of the green rectangle should lie(but doesn't)
       mPaint.setColor(Color.RED);
       canvas.drawPoint(210, 210, mPaint);
     }
    

    在没有开启硬件加速的情况下,矩形区域和红点显示正常,
    Canvas.getMatrix方法获取的Matrix也是在屏幕世界坐标系中的,即Matrix{[1.0, 0.0, 0.0][0.0, 1.0, 60.0][0.0, 0.0, 1.0]},其中Y轴位移为60,表示的就是状态栏的高度。这样重新setMatrix之后,就不会出现问题,如图所示:



    关闭硬件加速

    但是在开启硬件加速的情况下,矩形区域有一部分被系统栏遮挡住了,可以对比下红点的位置就就知道了,同时获取的Matrix也是相对于当前View本地坐标系的,即Matrix{[1.0, 0.0, 0.0][0.0, 1.0, 0.0][0.0, 0.0, 1.0]},没有产生任何位移。这样重新setMatrix之后,就会出现问题(因为对Matrix的理解不同),如图所示:开启硬件加速

    既然,Canvas.getMatrix被废弃了,那有什么替换的方法嘛?!这里Google并没有明确的指出。但是我觉得有两种方式可以实现类似功能。

    1. 不获取Matrix,直接通过Canvas提供的位移、旋转、缩放等API来实现类似功能。
    2. 从API11开始,提供了View Properties,可以直接对View进行位移、旋转、缩放等操作,同时也提供了View.getMatrix方法来获取当前View的Matrix(也算是Canvas.getMatrix的替代方案了)。当然,这个Matrix也是相对于View本身本地坐标系的。

    本文简单介绍了Matrix的基本使用方法,关于Matrix的底层原理,还没有涉猎,后续深入研究后,再补充进来。

    最后推荐几篇比较好的Matrix相关的文章。

    1. Android中图像变换Matrix的原理、代码验证和应用(一)
    2. Android中图像变换Matrix的原理、代码验证和应用(二)
    3. Android中图像变换Matrix的原理、代码验证和应用(三)
    4. 深入理解 Android 中的 Matrix

    展开全文
  • numpy教程:矩阵matrix及其运算

    万次阅读 2016-11-28 18:45:08
    NumPy函数库中存在两种不同的数据类型(矩阵matrix和数组array),都可以用于处理行列表示的数字元素。虽然它们看起来很相似,但是在这两个数据类型上执行相同的数学运算可能得到不同的结果,其中NumPy函数库中的...

    http://blog.csdn.net/pipisorry/article/details/48791403

    numpy矩阵简介

    NumPy函数库中存在两种不同的数据类型(矩阵matrix和数组array),都可以用于处理行列表示的数字元素。虽然它们看起来很相似,但是在这两个数据类型上执行相同的数学运算可能得到不同的结果,其中NumPy函数库中的matrix与MATLAB中matrices等价

    numpy模块中的矩阵对象为numpy.matrix,包括矩阵数据的处理,矩阵的计算,以及基本的统计功能,转置,可逆性等等,包括对复数的处理,均在matrix对象中。

    关于numpy中矩阵和二维数组的取舍

    matrix是array的分支,matrix和array在很多时候都是通用的,但官方建议如果两个可以通用,那就选择array,因为array更灵活,速度更快,很多人把二维的array也翻译成矩阵。
    matrix的优势就是相对简单的运算符号,如矩阵相乘用符号*,但是array相乘得用方法.dot()。

    Note: array * mat也是矩阵相乘,而不是点乘。

    array的优势就是不仅仅表示二维,还能表示3、4、5...维,而且在大部分Python程序里,array也是更常用的。

    Note:

    1. numpy中二维数组不支持求逆运算(给gui),但可以使用scripy中的linalg.inv()函数求逆。

    2. lz建议使用二维ndarray代替matrix,结合使用scripy.linalg库可以实现全部矩阵运算。[Scipy教程 - 线性代数库linalg]

    皮皮Blog



    Matrix objects矩阵对象

    创建示例

    np.matrix

    >>> a = np.matrix(’1 2; 3 4’)
    >>> print a
    [[1 2]
    [3 4]]

    >>> np.matrix([[1, 2], [3, 4]])
    matrix([[1, 2],
    [3, 4]])

    Note:

    1. class numpy.matrix(data,dtype,copy):返回一个矩阵,其中data为ndarray对象或者字符形式;dtype:为data的type;copy:为bool类型。

    2. 矩阵的换行必须是用分号(;)隔开,内部数据必须为字符串形式(‘ ’),矩阵的元素之间必须以空格隔开。

    3. 矩阵中的data可以为数组对象。

    np.asmatrix

    >>> x = np.array([[1, 2], [3, 4]])
    >>> m = np.asmatrix(x)
    >>> x[0,0] = 5
    >>> m
    matrix([[5, 2],
    [3, 4]])

    矩阵对象属性Attribute

    矩阵对象方法Methods

    [numpy-ref-1.8.1 - 1.6.2 Matrix objects p120]

    Matrix矩阵对象方法使用示例

    >>> a = np.asmatrix('0 2 7; 3 4 8; 5 0 9')
    >>> a.all()
    False
    >>> a.all(axis=0)
    matrix([[False, False,  True]], dtype=bool)
    >>> a.all(axis=1)
    matrix([[False],
    [ True],
    [False]], dtype=bool)
    
    ü  Astype方法
    >>> a.astype(float)
    matrix([[ 12.,   3.,   5.],
    [ 32.,  23.,   9.],
    [ 10., -14.,  78.]])
    
    ü  Argsort方法
    >>> a=np.matrix('12 3 5; 32 23 9; 10 -14 78')
    >>> a.argsort()
    matrix([[1, 2, 0],
    [2, 1, 0],
    [1, 0, 2]])
    
    ü  Clip方法
    >>> a
    matrix([[ 12,   3,   5],
    [ 32,  23,   9],
    [ 10, -14,  78]])
    >>> a.clip(12,32)
    matrix([[12, 12, 12],
    [32, 23, 12],
    [12, 12, 32]])
    
    ü  Cumprod方法
    >>> a.cumprod(axis=1)
    matrix([[    12,     36,    180],
    [    32,    736,   6624],
    [    10,   -140, -10920]])
    
    ü  Cumsum方法
    >>> a.cumsum(axis=1)
    matrix([[12, 15, 20],
    [32, 55, 64],
    [10, -4, 74]])
    
    ü  Tolist方法
    >>> b.tolist()
    [[12, 3, 5], [32, 23, 9], [10, -14, 78]]
    
    ü  Tofile方法
    >>> b.tofile('d:\\b.txt')
    
    ü  compress()方法
    >>> from numpy import *
    >>> a = array([10, 20, 30, 40])
    >>> condition = (a > 15) & (a < 35)
    >>> condition
    array([False, True, True, False], dtype=bool)
    >>> a.compress(condition)
    array([20, 30])
    >>> a[condition]                                      # same effect
    array([20, 30])
    >>> compress(a >= 30, a)                              # this form a
    so exists
    array([30, 40])
    >>> b = array([[10,20,30],[40,50,60]])
    >>> b.compress(b.ravel() >= 22)
    array([30, 40, 50, 60])
    >>> x = array([3,1,2])
    >>> y = array([50, 101])
    >>> b.compress(x >= 2, axis=1)                       # illustrates 
    the use of the axis keyword
    array([[10, 30],
    [40, 60]])
    >>> b.compress(y >= 100, axis=0)
    array([[40, 50, 60]])

    皮皮Blog



    The Matrix class numpy矩阵类

    建立矩阵


    Note: numpy.mat(data, dtype=None)   Interpret the input as a matrix.
    Unlike matrix, asmatrix does not make a copy if the input is already a matrix or an ndarray. Equivalent to matrix(data, copy=False).

    [numpy-ref-1.8.1 - 3.1.7 The Matrix class p484]

    皮皮Blog


    Matrix library矩阵库(numpy.matlib)

    This module contains all functions in the numpy namespace, with the following replacement functions that return matrices instead of ndarrays.

    Functions that are also in the numpy namespace and return matrices


    Replacement functions in matlib


    [numpy-ref-1.8.1 - 3.21 Matrix library p940]

    from:http://blog.csdn.net/pipisorry/article/details/48791403


    展开全文
  • Matrix用法

    千次阅读 2017-07-12 16:52:01
    Android中Matrix用法实例分析 这篇文章主要介绍了Android中Matrix用法,以实例形式分析了Matrix矩阵运算的常用技巧,具有一定参考借鉴价值,需要的朋友可以参考下 本文实例讲述了Android中Matrix用法。分享给...

    Android中Matrix用法实例分析

    这篇文章主要介绍了Android中Matrix用法,以实例形式分析了Matrix矩阵运算的常用技巧,具有一定参考借鉴价值,需要的朋友可以参考下

    本文实例讲述了Android中Matrix用法。分享给大家供大家参考,具体如下:

    Matrix ,中文里叫矩阵,高等数学里有介绍,在图像处理方面,主要是用于平面的缩放、平移、旋转等操作。

    首先介绍一下矩阵运算。加法和减法就不用说了,对应位相加就好。图像处理,主要用到的是乘法 。下面是一个乘法的公式:

    在 Android 里面, Matrix 由 9 个 float 值构成,是一个 3*3 的矩阵。如下图:

    解释一下,上面的sinX 和cosX ,表示旋转角度的cos 值和sin值,注意,旋转角度是按顺时针方向计算的。 translateX 和 translateY 表示 x 和 y 的平移量。 scale 是缩放的比例, 1 是不变, 2 是表示缩放 1/2 。

    Matrix的操作,总共分为translate(平移),rotate(旋转),scale(缩放)和skew(倾斜)四种,每一种变换在Android的API里都提供了set, post和pre三种操作方式,除了translate,其他三种操作都可以指定中心点。

    set是直接设置Matrix的值,每次set一次,整个Matrix的数组都会变掉。

    post是后乘,当前的矩阵乘以参数给出的矩阵。可以连续多次使用post,来完成所需的整个变换。例如,要将一个图片旋转30度,然后平移到(100,100)的地方,那么可以这样做:Matrix m =  new  Matrix();  m.postRotate(30 );  m.postTranslate(100 ,  100 ); 这样就达到了想要的效果。

    pre是前乘,参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。例如上面的例子,如果用pre的话,就要这样:Matrix m =  new  Matrix(); m.setTranslate(100 ,  100 );  m.preRotate(30 );

    旋转、缩放和倾斜都可以围绕一个中心点来进行,如果不指定,默认情况下,是围绕(0,0)点来进行。

    特别注意:

    Matrix的操作,总共分为translate(平移),rotate(旋转),scale(缩放)和skew(倾斜)四种,每一种变换在Android的API里都提供了set, post和pre三种操作方式,除了translate,其他三种操作都可以指定中心点。

    set是直接设置Matrix的值,每次set一次,整个Matrix的数组都会变掉。

    post是后乘,当前的矩阵乘以参数给出的矩阵。可以连续多次使用post,来完成所需的整个变换。

    镜面效果:

    倒影效果:

    图片的合成(水印):

    不多说了,直接上代码了。

    MainActivity.java里的主要代码如下:

    package net.loonggg.testmatrix; 
    import android.app.Activity; 
    import android.graphics.Bitmap; 
    import android.graphics.BitmapFactory; 
    import android.graphics.Canvas; 
    import android.graphics.Color; 
    import android.graphics.Matrix; 
    import android.graphics.Paint; 
    import android.graphics.PorterDuff.Mode; 
    import android.graphics.PorterDuffXfermode; 
    import android.os.Bundle; 
    import android.view.Window; 
    import android.widget.ImageView; 
    public class MainActivity extends Activity { 
      private ImageView iv1, iv2; 
      private Canvas canvas; 
      private Paint paint; 
      @Override 
      protected void onCreate(Bundle savedInstanceState) { 
        super.onCreate(savedInstanceState); 
        requestWindowFeature(Window.FEATURE_NO_TITLE); 
        setContentView(R.layout.activity_main); 
        iv1 = (ImageView) findViewById(R.id.iv1); 
        iv2 = (ImageView) findViewById(R.id.iv2); 
        Bitmap bitmap1 = BitmapFactory.decodeResource(getResources(), 
            R.drawable.weibo); 
        Bitmap updateBitmap = Bitmap.createBitmap(bitmap1.getWidth() * 2, 
            bitmap1.getHeight() * 2, bitmap1.getConfig()); 
        canvas = new Canvas(updateBitmap); 
        paint = new Paint(); 
        paint.setColor(Color.BLACK); 
        Matrix matrix = new Matrix(); 
        // setMirrorOne(bitmap1, matrix); 
        // setInvertedImage(bitmap1, matrix); 
        // setBaseChange(matrix); 
        canvas.drawBitmap(bitmap1, matrix, paint); 
        setImageSynthesis(matrix); 
        iv1.setImageBitmap(bitmap1); 
        iv2.setImageBitmap(updateBitmap); 
      } 
      /** 
       * 还有一些基本变化 
       */ 
      private void setBaseChange(Matrix matrix) { 
        // matrix.setRotate(60);// 这是旋转多少度 
        // matrix.setRotate(degrees, px, py);//这个方法是以哪个点为中心进行旋转多少度 
        // matrix.setSkew(kx, ky);//设置倾斜,以x轴倾斜,还是y轴 
        // 倾斜x和y轴,以(100,100)为中心。 
        // matrix.postSkew(0 .2f, 0 .2f, 100 , 100 ); 
        // matrix.setScale(0.5f, 1);//缩放宽度变为原来的一半,高度不变 
      } 
      /** 
       * 设置倒影效果 
       * 
       * @param bitmap1 
       * @param matrix 
       */ 
      private void setInvertedImage(Bitmap bitmap1, Matrix matrix) { 
        matrix.setScale(1, -1); 
        matrix.postTranslate(0, bitmap1.getHeight()); 
      } 
      /** 
       * 设置镜面效果方法一 
       * 
       * @param bitmap1 
       * @param matrix 
       */ 
      private void setMirrorOne(Bitmap bitmap1, Matrix matrix) { 
        matrix.setTranslate(bitmap1.getWidth(), 0);// 这个是移动 
        matrix.preScale(-1, 1); 
      } 
      // --------------------------------------------------------- 
      /** 
       * 解释:镜面效果方法一和二的区别: 
       * 不知道大家看没看出来,其实这两种方法的效果是一样的,只不过是设置步骤不一样,post是后乘,当前的矩阵乘以参数给出的矩阵 
       * 。可以连续多次使用post,来完成所需的整个变换。 pre是前乘,参数给出的矩阵乘以当前的矩阵。所以操作是在当前矩阵的最前面发生的。 
       * 可以连续多次使用post 
       * ,来完成所需的整个变换,但是不可以连续使用set来完成矩阵的整个变换,为什么呢?set是直接设置Matrix的值,每次set一次 
       * ,整个Matrix的数组都会变掉,第一次可以使用set,之后的变换必须换成post或者pre,也可以一直用post也行 
       */ 
      // --------------------------------------------------------- 
      /** 
       * 设置镜面效果方法二 
       * 
       * @param bitmap1 
       * @param matrix 
       */ 
      private void setMirrorTwo(Bitmap bitmap1, Matrix matrix) { 
        matrix.setScale(-1, 1); 
        matrix.postTranslate(bitmap1.getWidth(), 0); 
      } 
      /** 
       * 设置图片的合成 
       * 
       * @param matrix 
       */ 
      private void setImageSynthesis(Matrix matrix) { 
        Bitmap bitmap2 = BitmapFactory.decodeResource(getResources(), 
            R.drawable.ic_launcher); 
        // 设置图片合成时的各种模式 
        paint.setXfermode(new PorterDuffXfermode(Mode.DARKEN)); 
        // 图片的合成很简单,就是再以bitmap2为基图往目标图片上画一次 
        canvas.drawBitmap(bitmap2, matrix, paint); 
      } 
    }
    
    

    布局文件的代码如下:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" 
      xmlns:tools="http://schemas.android.com/tools" 
      android:layout_width="match_parent" 
      android:layout_height="match_parent" 
      android:orientation="vertical" 
      tools:context=".MainActivity" > 
      <ImageView 
        android:id="@+id/iv1" 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" /> 
      <ImageView 
        android:id="@+id/iv2" 
        android:layout_width="wrap_content" 
        android:layout_height="wrap_content" /> 
    </LinearLayout>
    
    

    希望本文所述对大家Android程序设计有所帮助。

    展开全文
  • R语言矩阵(matrix)详解

    万次阅读 2014-09-11 14:19:53
    数据: 1 3 9 8 9 80 1 4 2 7 88 1 22 21 ...1)向量转化为矩阵c—>matrix tmp_matrix tmp_matrix tmp_matrix 或者 tmp_matrix tmp_matrix tmp_matrix 数据: col1 col2 col3 col4 col5 col6 col
    数据:
    1 3 9 8 9 80 1
    4 2 7 88 1 22 21

    31 2 44 9 10 9 10


    使用矩阵表示
    1)向量转化为矩阵c—>matrix
    tmp_matrix<-matrix(c(1,3,9,8,9,80,1,4,2,7,88,1,22,21,31,2,44,9,10,9,10),nrow=3,ncol=7,byrow=TRUE)
    tmp_matrix<-matrix(c(1,3,9,8,9,80,1,4,2,7,88,1,22,21,31,2,44,9,10,9,10),ncol=7,byrow=TRUE)
    tmp_matrix<-matrix(c(1,3,9,8,9,80,1,4,2,7,88,1,22,21,31,2,44,9,10,9,10),nrow=3,byrow=TRUE)
    或者
    tmp_matrix<-matrix(c(1,4,31,3,2,2,9,7,44,8,88,9,9,1,10,80,22,9,1,21,10),nrow=3,ncol=7,byrow=FALSE)
    tmp_matrix<-matrix(c(1,4,31,3,2,2,9,7,44,8,88,9,9,1,10,80,22,9,1,21,10),nrow=3)
    tmp_matrix<-matrix(c(1,4,31,3,2,2,9,7,44,8,88,9,9,1,10,80,22,9,1,21,10),ncol=7)—–建议使用
    数据:
    col1 col2 col3 col4 col5 col6 col7
    row1 1 3 9 8 9 80 1
    row2 4 2 7 88 1 22 21

    row3 31 2 44 9 10 9 10


    2)为矩阵添加名称dimnames参数
    tmp_matrix<-matrix(c(1,4,31,3,2,2,9,7,44,8,88,9,9,1,10,80,22,9,1,21,10),ncol=7,dimnames=list(c(“row1″,”row2″,”row3″),c
    (“col1″,”col2″,”col3″,”col4″,”col5″,”col6″,”col7″)))
    或者
    rownames(tmp_matrix)<-c(“row1″,”row2″,”row3″)
    colnames(tmp_matrix)<-c(“col1″,”col2″,”col3″,”col4″,”col5″,”col6″,”col7″)
    读取数据-无dimnames
    行数据
    tmp_matrix[1,]是向量: 1,3,9,8,9,80,1
    tmp_matrix[2,]是向量: 4,2,7,88,1,22,21
    tmp_matrix[3,]是向量: 31,2,44,9,10,9,10
    列数据
    tmp_matrix[,1]是向量: 1,4,31
    tmp_matrix[,2]是向量: 3,2,2
    tmp_matrix[,3]是向量: 9,7,44
    tmp_matrix[,4]是向量: 8,88,9
    tmp_matrix[,5]是向量: 9,1,10
    tmp_matrix[,6]是向量: 80,22,9
    tmp_matrix[,7]是向量: 1,21,10
    点数据
    tmp_matrix[i,j]是数据:i行j列的数据
    读取数据-有dimnames
    行数据
    tmp_matrix[1,]和tmp_matrix["row1",]是第1行的向量
    列数据
    tmp_matrix[,1]和tmp_matrix[,"col1"]是第1列的向量
    点数据
    tmp_matrix[1,2]和tmp_matrix["row1","col2"]是第1行第2列的向量
    读取名称
    >dimnames(tmp_matrix)#是list
    [[1]]
    [1] “row1″ “row2″ “row3″
    [[2]]
    [1] “col1″ “col2″ “col3″ “col4″ “col5″ “col6″ “col7″
    > rownames(tmp_matrix)#是向量
    [1] “row1″ “row2″ “row3″
    > colnames(tmp_matrix)#是向量
    [1] “col1″ “col2″ “col3″ “col4″ “col5″ “col6″ “col7″
    > rownames(tmp_matrix)[2]
    [1] “row2″
    > colnames(tmp_matrix)[4]
    [1] “col4″
     
    空矩阵
    a<-matrix(0,nrow=12,ncol=11)
    矩阵扩展
    扩展列
    >cbind(tmp_matrix,c(1,1,2))
    col1 col2 col3 col4 col5 col6 col7
    row1 1 3 9 8 9 80 1 1
    row2 4 2 7 88 1 22 21 1
    row3 31 2 44 9 10 9 10 2
    扩展行
    >rbind(tmp_matrix,c(1,1,2,2,1,1,9))
    col1 col2 col3 col4 col5 col6 col7
    row1 1 3 9 8 9 80 1
    row2 4 2 7 88 1 22 21
    row3 31 2 44 9 10 9 10
    1 1 2 2 1 1 9
    矩阵变为向量
    >as.vector(tmp_matrix)#依据列方式
    [1] 1 4 31 3 2 2 9 7 44 8 88 9 9 1 10 80 22 9 1 21 10
     
    数据内部的数据类型
    > tmp_matrix<-matrix(c(1,1,31,3,2,2,9,1,44,8,88,9,9,1,10,80,22,9,1,21,10),ncol=7)
    > tmp_matrix
    [,1] [,2] [,3] [,4] [,5] [,6] [,7]
    [1,] 1 3 9 8 9 80 1
    [2,] 1 2 1 88 1 22 21
    [3,] 31 2 44 9 10 9 10
    > tmp_matrix<-matrix(c(1,”4sssss”,31,3,2,2,9,”7aaaaaa”,44,8,88,9,9,1,10,80,22,9,1,21,10),ncol=7)
    > tmp_matrix
    [,1] [,2] [,3] [,4] [,5] [,6] [,7]
    [1,] “1″ “3″ “9″ “8″ “9″ “80″ “1″
    [2,] “4sssss” “2″ “7aaaaaa” “88″ “1″ “22″ “21″
    [3,] “31″ “2″ “44″ “9″ “10″ “9″ “10″
    当改变一个数据为字符时候(“xxx”),其余数据全部改变了字符类型。
    展开全文
  • CSS matrix() 方法

    万次阅读 2018-07-14 16:27:40
    matrix() 方法把所有 2D 转换方法组合在一起。matrix() 方法需要六个参数,包含数学函数,允许您:旋转、缩放、移动以及倾斜元素。matrix()中的6个参数代表了一个3*3的矩阵(线性代数)。平移在CSS3中我们矩阵的原始...
  • Matrix学习笔记(一):原理

    千次阅读 2016-08-18 13:15:37
    基本概念 缩放 错切Skew 旋转Rotate 平移Translate Matrix复合原理 下面我们用不同对方式来构造一个矩阵 仅用pre 仅用post 混合 Matrix方法表基本概念错切:实际上是平面...Matrix :是一个3维矩阵,最根本的作用就是
  • Matrix类详解

    千次阅读 2018-10-07 21:46:12
    Matrix的三参数定义原型 Matrix的三参数实例 列Vector与行Vector的常用定义 动态向量与数组的定义 Vector与Matrix构造器 矩阵与向量的系数存储操作实例 #include &lt;iostream&gt; #...
  • 浅谈矩阵变换——Matrix

    万次阅读 2017-09-07 11:34:05
    矩阵变换在图形学上经常用到。基本的常用矩阵变换操作包括平移、缩放、旋转、斜切。 每种变换都对应一个变换矩阵,通过矩阵乘法,可以把多个变换矩阵相乘得到复合变换矩阵。 ...矩阵乘法不支持交换律,因此不同的...
  • python 中的常用矩阵(matrix)操作

    千次阅读 2019-03-07 20:56:43
    本文转载于:峻之岭峰 Numpy 通过观察Python的自有数据类型,我们可以发现Python原生并不提供多维数组的操作,那么为了处理矩阵,就需要使用第三方提供的相关的包。 NumPy 是一个非常优秀的提供矩阵操作的包。...
  • python的dataframe和matrix的互换

    万次阅读 2016-08-01 21:05:28
    #-*- encoding:utf-8 -*- import pandas as pd import numpy as np df = pd.DataFrame(np.random.randn(3,4) ,columns=list('abcd')) print df print df.values print df.as_matrix(columns=None)
  • C语言实现矩阵运算

    万次阅读 多人点赞 2020-07-15 20:11:16
    最近在学习机器人运动控制学,用到了矩阵运算,并用C语言实现之 一个矩阵最基本的有行数line,列数row和 行数乘以列数个数据(row*line), 所以用一个最基本的...}Matrix; 这样在创建一个矩阵的时候只需要分配ro...
  • matlab报错:Index exceeds matrix dimensions.

    万次阅读 2018-06-13 17:44:02
    matlab报错:Index exceeds matrix dimensions. 如何解决???引用矩阵元素超过界限了。比如矩阵A是4*4的,你却引用了A(4,5),
  • 6轴机器人运动学正解,逆解1

    万次阅读 多人点赞 2017-12-15 13:52:05
    正解 给定机器人各关节的角度,计算出机器人末端的空间位置逆解 已知机器人末端的位置和姿态,计算机器人各关节的角度值常见的工业机器人 正解与逆解的求解需要相应的机器人运动方程,其中关键的就是DH参数表 ...
  • android利用matrix对图片中心旋转

    万次阅读 2011-10-10 23:12:50
    具体原理我真的不知道是什么,因为matrix类设计到矩阵相乘之类的知识,没研究清楚,全靠穷举法试出来的,如果读者知道其原理很希望和你交流经验。 我只贴出最关键的几行代码: Bitmap a; //之下省略一系列的引用...
  • python二维列表转置

    万次阅读 2018-08-24 21:51:23
    python 二维列表转置 def transpose(self, matrix): new_matrix = [] for i in range(len(matrix[0])): matrix1 = [] for j in range(len(matrix)): matrix1.a...
  • The matrix cookbook (矩阵计算)pdf

    万次阅读 多人点赞 2018-05-08 16:16:51
    The matrix cookbook (矩阵计算)pdf版本,适合矩阵求导和计算,下载链接:下载地址
  • .as_matrix()的作用

    万次阅读 2019-03-24 22:02:51
    在我们读取一些excel/csv文件的数据后,在训练模型之前经常要对数据进行数组转化 解释含义如下: Convert the frame to its Numpy-array representation. 当然很多时候在提取完数据后其自身就是数组形式(<...
  • adjacent matrix和affinity matrix之间的区别

    千次阅读 热门讨论 2018-06-17 21:22:47
    adjacent matrix 是一个方阵,描述的是点与点之间的关系比如一个图如果使用 adjacent matrix 其邻接矩阵应该是但是使用 affnity matrix 则表示的是点和边之间的关系,...
  • [Numpy]array与matrix在乘法上的不同

    万次阅读 2020-03-26 17:45:06
    [Numpy]array与matrix在乘法上的不同1 Numpy乘法的实现2 上代码(array,matrix在*,dot,multiply上的异同)2.1 定义array和matrix两个矩阵2.2 取array和matrix的第一行2.3 取array和matrix的第一列2.4 array进行...
  • pandas.DataFrame.as_matrix

    万次阅读 2017-09-09 22:42:22
    pandas.DataFrame.as_matrix
1 2 3 4 5 ... 20
收藏数 304,840
精华内容 121,936
关键字:

matrix