devbox
我家小花儿
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

NO.48------ C#实现卡尔曼滤波_c# 卡尔曼滤波

作者：我家小花儿 | 2024-02-21 10:31:36

赞

踩

c# 卡尔曼滤波

通俗的讲，卡尔曼滤波就是综合上一步骤对当前步骤的预测值，结合当前步骤的测量值，来估计当前的状态。

       最近在做一个Unity项目时，用到了卡尔曼滤波消除抖动,主要是消除头部抖动，从Dlib实时获得68个特征值的points，由points.x points.y  points.z  获得头部的旋转四元数作为测量值，初始值可以任意定义，因为几次迭代后预测值就逼近真实值了。因为Unity用c#编写，c#本身不存在矩阵库，对矩阵运算比较吃力，需要自己导入矩阵库，方法很简单，首先定义矩阵库的命名空间，然后使用该命名空间即可。

矩阵库：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5.  
  6.  
  7. namespace Slash.Lastwork
  8. {
  9.     public class Matrix
  10.     {
  11.         double[,] A;
  12.         //m行n列
  13.         int m, n;
  14.         string name;
  15.         public Matrix(int am, int an)
  16.         {
  17.             m = am;
  18.             n = an;
  19.             A = new double[m, n];
  20.             name = "Result";
  21.         }
  22.         public Matrix(int am, int an, string aName)
  23.         {
  24.             m = am;
  25.             n = an;
  26.             A = new double[m, n];
  27.             name = aName;
  28.         }
  29.  
  30.         public int getM
  31.         {
  32.             get { return m; }
  33.         }
  34.         public int getN
  35.         {
  36.             get { return n; }
  37.         }
  38.         public double[,] Detail
  39.         {
  40.             get { return A; }
  41.             set { A = value; }
  42.         }
  43.         public string Name
  44.         {
  45.             get { return name; }
  46.             set { name = value; }
  47.         }
  48.     }
  49.     public class MatrixOperator
  50.     {
  51.         MatrixOperator()
  52.         { }
  53.         /// <summary>
  54.         /// 矩阵加法
  55.         /// </summary>
  56.         /// <param name="Ma"></param>
  57.         /// <param name="Mb"></param>
  58.         /// <returns></returns>
  59.         public static Matrix MatrixAdd(Matrix Ma, Matrix Mb)
  60.         {
  61.             int m = Ma.getM;
  62.             int n = Ma.getN;
  63.             int m2 = Mb.getM;
  64.             int n2 = Mb.getN;
  65.  
  66.             if ((m != m2) || (n != n2))
  67.             {
  68.                 Exception myException = new Exception("数组维数不匹配");
  69.                 throw myException;
  70.             }
  71.  
  72.             Matrix Mc = new Matrix(m, n);
  73.             double[,] c = Mc.Detail;
  74.             double[,] a = Ma.Detail;
  75.             double[,] b = Mb.Detail;
  76.  
  77.             int i, j;
  78.             for (i = 0; i < m; i++)
  79.                 for (j = 0; j < n; j++)
  80.                     c[i, j] = a[i, j] + b[i, j];
  81.  
  82.             return Mc;
  83.         }
  84.         /// <summary>
  85.         /// 矩阵减法
  86.         /// </summary>
  87.         /// <param name="Ma"></param>
  88.         /// <param name="Mb"></param>
  89.         /// <returns></returns>
  90.         public static Matrix MatrixSub(Matrix Ma, Matrix Mb)
  91.         {
  92.             int m = Ma.getM;
  93.             int n = Ma.getN;
  94.             int m2 = Mb.getM;
  95.             int n2 = Mb.getN;
  96.  
  97.             if ((m != m2) || (n != n2))
  98.             {
  99.                 Exception myException = new Exception("数组维数不匹配");
  100.                 throw myException;
  101.             }
  102.  
  103.             Matrix Mc = new Matrix(m, n);
  104.             double[,] c = Mc.Detail;
  105.             double[,] a = Ma.Detail;
  106.             double[,] b = Mb.Detail;
  107.  
  108.             int i, j;
  109.             for (i = 0; i < m; i++)
  110.                 for (j = 0; j < n; j++)
  111.                     c[i, j] = a[i, j] - b[i, j];
  112.  
  113.             return Mc;
  114.         }
  115.         /// <summary>
  116.         /// 矩阵打印
  117.         /// </summary>
  118.         /// <param name="Ma"></param>
  119.         /// <returns></returns>
  120.         public static string MatrixPrint(Matrix Ma)
  121.         {
  122.             string s;
  123.             s = Ma.Name + ":\n";
  124.  
  125.             int m = Ma.getM;
  126.             int n = Ma.getN;
  127.  
  128.             double[,] a = Ma.Detail;
  129.  
  130.             for (int i = 0; i < m; i++)
  131.             {
  132.                 for (int j = 0; j < n; j++)
  133.                 {
  134.                     s += a[i, j].ToString("0.0000") + "\t";
  135.                 }
  136.                 s += "\n";
  137.             }
  138.             return s;
  139.         }
  140.         /// <summary>
  141.         /// 矩阵乘法
  142.         /// </summary>
  143.         /// <param name="Ma"></param>
  144.         /// <param name="Mb"></param>
  145.         /// <returns></returns>
  146.         public static Matrix MatrixMulti(Matrix Ma, Matrix Mb)
  147.         {
  148.             int m = Ma.getM;
  149.             int n = Ma.getN;
  150.             int m2 = Mb.getM;
  151.             int n2 = Mb.getN;
  152.  
  153.             if (n != m2)
  154.             {
  155.                 Exception myException = new Exception("数组维数不匹配");
  156.                 throw myException;
  157.             }
  158.  
  159.             Matrix Mc = new Matrix(m, n2);
  160.             double[,] c = Mc.Detail;
  161.             double[,] a = Ma.Detail;
  162.             double[,] b = Mb.Detail;
  163.  
  164.             int i, j, k;
  165.             for (i = 0; i < m; i++)
  166.                 for (j = 0; j < n2; j++)
  167.                 {
  168.                     c[i, j] = 0;
  169.                     for (k = 0; k < n; k++)
  170.                         c[i, j] += a[i, k] * b[k, j];
  171.                 }
  172.  
  173.             return Mc;
  174.         }
  175.         /// <summary>
  176.         /// 矩阵数乘
  177.         /// </summary>
  178.         /// <param name="k"></param>
  179.         /// <param name="Ma"></param>
  180.         /// <returns></returns>
  181.         public static Matrix MatrixSimpleMulti(double k, Matrix Ma)
  182.         {
  183.             int n = Ma.getN;
  184.             int m = Ma.getM;
  185.             Matrix Mc = new Matrix(m, n);
  186.             double[,] c = Mc.Detail;
  187.             double[,] a = Ma.Detail;
  188.  
  189.             int i, j;
  190.             for (i = 0; i < m; i++)
  191.                 for (j = 0; j < n; j++)
  192.                     c[i, j] = a[i, j] * k;
  193.  
  194.             return Mc;
  195.         }
  196.         /// <summary>
  197.         /// 矩阵转置
  198.         /// </summary>
  199.         /// <param name="Ma"></param>
  200.         /// <param name="Mb"></param>
  201.         /// <returns></returns>
  202.         public static Matrix MatrixTrans(Matrix Ma)
  203.         {
  204.             int m = Ma.getM;
  205.             int n = Ma.getN;
  206.             Matrix Mc = new Matrix(n, m);
  207.             double[,] c = Mc.Detail;
  208.             double[,] a = Ma.Detail;
  209.  
  210.             for (int i = 0; i < n; i++)
  211.                 for (int j = 0; j < m; j++)
  212.                     c[i, j] = a[j, i];
  213.  
  214.             return Mc;
  215.         }
  216.         /// <summary>
  217.         /// 矩阵求逆(高斯法)
  218.         /// </summary>
  219.         /// <param name="Ma"></param>
  220.         /// <returns></returns>
  221.         public static Matrix MatrixInv(Matrix Ma)
  222.         {
  223.             int m = Ma.getM;
  224.             int n = Ma.getN;
  225.             if (m != n)
  226.             {
  227.                 Exception myException = new Exception("数组维数不匹配");
  228.                 throw myException;
  229.             }
  230.             Matrix Mc = new Matrix(m, n);
  231.             double[,] a0 = Ma.Detail;
  232.             double[,] a = (double[,])a0.Clone();
  233.             double[,] b = Mc.Detail;
  234.  
  235.             int i, j, row, k;
  236.             double max, temp;
  237.  
  238.             //单位矩阵
  239.             for (i = 0; i < n; i++)
  240.             {
  241.                 b[i, i] = 1;
  242.             }
  243.             for (k = 0; k < n; k++)
  244.             {
  245.                 max = 0; row = k;
  246.                 //找最大元，其所在行为row
  247.                 for (i = k; i < n; i++)
  248.                 {
  249.                     temp = Math.Abs(a[i, k]);
  250.                     if (max < temp)
  251.                     {
  252.                         max = temp;
  253.                         row = i;
  254.                     }
  255.  
  256.                 }
  257.                 if (max == 0)
  258.                 {
  259.                     Exception myException = new Exception("没有逆矩阵");
  260.                     throw myException;
  261.                 }
  262.                 //交换k与row行
  263.                 if (row != k)
  264.                 {
  265.                     for (j = 0; j < n; j++)
  266.                     {
  267.                         temp = a[row, j];
  268.                         a[row, j] = a[k, j];
  269.                         a[k, j] = temp;
  270.  
  271.                         temp = b[row, j];
  272.                         b[row, j] = b[k, j];
  273.                         b[k, j] = temp;
  274.                     }
  275.  
  276.                 }
  277.  
  278.                 //首元化为1
  279.                 for (j = k + 1; j < n; j++) a[k, j] /= a[k, k];
  280.                 for (j = 0; j < n; j++) b[k, j] /= a[k, k];
  281.  
  282.                 a[k, k] = 1;
  283.  
  284.                 //k列化为0
  285.                 //对a
  286.                 for (j = k + 1; j < n; j++)
  287.                 {
  288.                     for (i = 0; i < k; i++) a[i, j] -= a[i, k] * a[k, j];
  289.                     for (i = k + 1; i < n; i++) a[i, j] -= a[i, k] * a[k, j];
  290.                 }
  291.                 //对b
  292.                 for (j = 0; j < n; j++)
  293.                 {
  294.                     for (i = 0; i < k; i++) b[i, j] -= a[i, k] * b[k, j];
  295.                     for (i = k + 1; i < n; i++) b[i, j] -= a[i, k] * b[k, j];
  296.                 }
  297.                 for (i = 0; i < n; i++) a[i, k] = 0;
  298.                 a[k, k] = 1;
  299.             }
  300.  
  301.             return Mc;
  302.         }
  303.         /// <summary>
  304.         /// 矩阵求逆(伴随矩阵法)
  305.         /// </summary>
  306.         /// <param name="Ma"></param>
  307.         /// <returns></returns>
  308.         public static Matrix MatrixInvByCom(Matrix Ma)
  309.         {
  310.             double d = MatrixOperator.MatrixDet(Ma);
  311.             if (d == 0)
  312.             {
  313.                 Exception myException = new Exception("没有逆矩阵");
  314.                 throw myException;
  315.             }
  316.             Matrix Ax = MatrixOperator.MatrixCom(Ma);
  317.             Matrix An = MatrixOperator.MatrixSimpleMulti((1.0 / d), Ax);
  318.             return An;
  319.         }
  320.         /// <summary>
  321.         /// 对应行列式的代数余子式矩阵
  322.         /// </summary>
  323.         /// <param name="Ma"></param>
  324.         /// <returns></returns>
  325.         public static Matrix MatrixSpa(Matrix Ma, int ai, int aj)
  326.         {
  327.             int m = Ma.getM;
  328.             int n = Ma.getN;
  329.             if (m != n)
  330.             {
  331.                 Exception myException = new Exception("数组维数不匹配");
  332.                 throw myException;
  333.             }
  334.             int n2 = n - 1;
  335.             Matrix Mc = new Matrix(n2, n2);
  336.             double[,] a = Ma.Detail;
  337.             double[,] b = Mc.Detail;
  338.  
  339.             //左上
  340.             for (int i = 0; i < ai; i++)
  341.                 for (int j = 0; j < aj; j++)
  342.                 {
  343.                     b[i, j] = a[i, j];
  344.                 }
  345.             //右下
  346.             for (int i = ai; i < n2; i++)
  347.                 for (int j = aj; j < n2; j++)
  348.                 {
  349.                     b[i, j] = a[i + 1, j + 1];
  350.                 }
  351.             //右上
  352.             for (int i = 0; i < ai; i++)
  353.                 for (int j = aj; j < n2; j++)
  354.                 {
  355.                     b[i, j] = a[i, j + 1];
  356.                 }
  357.             //左下
  358.             for (int i = ai; i < n2; i++)
  359.                 for (int j = 0; j < aj; j++)
  360.                 {
  361.                     b[i, j] = a[i + 1, j];
  362.                 }
  363.             //符号位
  364.             if ((ai + aj) % 2 != 0)
  365.             {
  366.                 for (int i = 0; i < n2; i++)
  367.                     b[i, 0] = -b[i, 0];
  368.  
  369.             }
  370.             return Mc;
  371.         }
  372.         /// <summary>
  373.         /// 矩阵的行列式
  374.         /// </summary>
  375.         /// <param name="Ma"></param>
  376.         /// <returns></returns>
  377.         public static double MatrixDet(Matrix Ma)
  378.         {
  379.             int m = Ma.getM;
  380.             int n = Ma.getN;
  381.             if (m != n)
  382.             {
  383.                 Exception myException = new Exception("数组维数不匹配");
  384.                 throw myException;
  385.             }
  386.             double[,] a = Ma.Detail;
  387.             if (n == 1) return a[0, 0];
  388.  
  389.             double D = 0;
  390.             for (int i = 0; i < n; i++)
  391.             {
  392.                 D += a[1, i] * MatrixDet(MatrixSpa(Ma, 1, i));
  393.             }
  394.             return D;
  395.         }
  396.         /// <summary>
  397.         /// 矩阵的伴随矩阵
  398.         /// </summary>
  399.         /// <param name="Ma"></param>
  400.         /// <returns></returns>
  401.         public static Matrix MatrixCom(Matrix Ma)
  402.         {
  403.             int m = Ma.getM;
  404.             int n = Ma.getN;
  405.             Matrix Mc = new Matrix(m, n);
  406.             double[,] c = Mc.Detail;
  407.             double[,] a = Ma.Detail;
  408.  
  409.             for (int i = 0; i < m; i++)
  410.                 for (int j = 0; j < n; j++)
  411.                     c[i, j] = MatrixDet(MatrixSpa(Ma, j, i));
  412.  
  413.             return Mc;
  414.         }
  415.     }
  416.  
  417.  
  418. }

迭代过程：

  1. using UnityEngine;
  2. using System.Collections.Generic;
  3. using System;
  4. using System.IO;
  5. using Slash.Lastwork;
  6.  
  7. #if UNITY_5_3 || UNITY_5_3_OR_NEWER
  8. using UnityEngine.SceneManagement;
  9. #endif
  10. using OpenCVForUnity;
  11. using DlibFaceLandmarkDetector;
  12. using DlibFaceLandmarkDetectorSample;
  13. using Moments;
  14.  
  15. namespace Slash.Facemoji
  16. {
  17.     /// <summary>
  18.     /// FaceTracking, Use Dlib to detect face landmark and use Live2D model to track faces
  19.     /// </summary>
  20.     [AddComponentMenu("Facemoji/FaceTracking")]
  21.     [RequireComponent (typeof(WebCamTextureToMatHelper))]
  22.     public class FaceTracking : MonoBehaviour
  23.     {
  24.         ///矩阵的运算
  25.         //F_K 状态转移矩阵
  26.         Matrix stateConvert = new Matrix(6, 6, "stateConvert");
  27.         //P_K 后验估计误差协方差矩阵，度量估计值的精确程度
  28.         Matrix errorCovPost = new Matrix(6, 6, "errorCovPsot");
  29.         //H_K 观测矩阵
  30.         Matrix measureMatrix = new Matrix(6, 3, "measureMatrix");
  31.         //Q_K 过程噪声
  32.         Matrix processNoiseConvert = new Matrix(6, 6, "processNoiseConvert");
  33.         //R_K 观测噪声
  34.         Matrix measureNoiseConvert = new Matrix(3, 3, "measureNoiseConvert");
  35.         //X_0 初始状态
  36.         Matrix originState = new Matrix(3, 1, "originState");
  37.         /// <summary>
  38.         /// All Live2D Texture
  39.         /// </summary>
  40.         private enum WhichTexture
  41.         {
  42.             noir_santa = 1,
  43.             uni = 2,
  44.         };
  45.  
  46.         /// <summary>
  47.         /// The selected Live2D Texture now.(Default shizuku)
  48.         /// </summary>
  49.         private WhichTexture selectedTexture = WhichTexture.uni;
  50.  
  51.         /// <summary>
  52.         /// Start Button
  53.         /// </summary>
  54.         public static GameObject startBtn;
  55.  
  56.         /// <summary>
  57.         /// Finish Button
  58.         /// </summary>
  59.         public static GameObject finishBtn;
  60.  
  61.         /// <summary>
  62.         /// live2DModel.transform.localScale
  63.         /// </summary>
  64.         public float modelScale = 0.9f;
  65.  
  66.         /// <summary>
  67.         /// The web cam texture to mat helper.
  68.         /// </summary>
  69.         WebCamTextureToMatHelper webCamTextureToMatHelper;
  70.  
  71.         /// <summary>
  72.         /// The face landmark detector.
  73.         /// </summary>
  74.         FaceLandmarkDetector faceLandmarkDetector;
  75.  
  76.         /// <summary>
  77.         /// The live2DModel.
  78.         /// </summary>
  79.         public Live2DModel live2DModel;
  80.  
  81.         /// <summary>
  82.         /// The frontal face parameter.
  83.         /// </summary>
  84.         FrontalFaceParam frontalFaceParam;
  85.  
  86.         /// <summary>
  87.         /// The shape_predictor_68_face_landmarks_dat_filepath.
  88.         /// </summary>
  89.         private string shape_predictor_68_face_landmarks_dat_filepath;
  90.  
  91.         /// <summary>
  92.         /// Model file path.
  93.         /// </summary>
  94.         private string moc_filepath;
  95.         private string physics_filepath;
  96.         private string pose_filepath;
  97.         private string[] texture_filepath = new string[6];
  98.  
  99.         /// <summary>
  100.         /// 相关矩阵的计算.
  101.         /// </summary>
  102.         //F_K 状态转移矩阵
  103.         Matrix F_K = new Matrix(6, 6, "F_K");
  104.         //P_K 后验估计误差协方差矩阵，度量估计值的精确程度
  105.         Matrix P_K = new Matrix(6, 6, "errorCovPsot");
  106.         //P_k+1
  107.         Matrix P_front = new Matrix(6, 6, "errorCovPsot");
  108.         //H_K 观测矩阵
  109.         Matrix H_K = new Matrix(3, 6, "H_K");
  110.         //Q_K 过程噪声
  111.         Matrix Q_K = new Matrix(6, 6, "Q_K");
  112.         //R_K 观测噪声
  113.         Matrix R_K = new Matrix(3, 3, "R_K");
  114.         //Z_K 测量值
  115.         Matrix Z_K = new Matrix(3, 1, "Z_K");
  116.         //X_K 
  117.         Matrix X_K = new Matrix(6, 1, "state");
  118.         //X_K+1 
  119.         Matrix X_front = new Matrix(6, 1, "state");
  120.         //eye
  121.         Matrix eye = new Matrix(6, 6, "state");
  122.  
  123.  
  124.         // Use this for initialization
  125.         void Start()
  126.         {
  127.             startBtn = GameObject.Find("StartButton");
  128.             finishBtn = GameObject.Find("FinishButton");
  129.             startBtn.SetActive(true);
  130.             finishBtn.SetActive(false);
  131.  
  132.             webCamTextureToMatHelper = gameObject.GetComponent<WebCamTextureToMatHelper>();
  133.  
  134. #if UNITY_WEBGL && !UNITY_EDITOR
  135.             webCamTextureToMatHelper.flipHorizontal = true;
  136.             StartCoroutine(getFilePathCoroutine());
  137. #else
  138.             // FaceLandmark model filepath
  139.             shape_predictor_68_face_landmarks_dat_filepath = DlibFaceLandmarkDetector.Utils.getFilePath("shape_predictor_68_face_landmarks.dat");
  140.  
  141.             // Load Texture filepath
  142.             LoadTexture();
  143.             
  144.             Run();
  145. #endif
  146.         }
  147.  
  148.         private void LoadTexture()
  149.         {
  150.             // Load model filepath
  151.             switch (selectedTexture)
  152.             {
  153.                 case WhichTexture.noir_santa:
  154.                     {
  155.                         moc_filepath = OpenCVForUnity.Utils.getFilePath("noir_santa/noir_santa.moc.bytes");
  156.                         physics_filepath = OpenCVForUnity.Utils.getFilePath("noir_santa/noir_santa.physics.json");
  157.                         pose_filepath = OpenCVForUnity.Utils.getFilePath("noir_santa/noir_santa.pose.json");
  158.                         for (int i = 0; i < texture_filepath.Length; i++)
  159.                         {
  160.                             texture_filepath[i] = OpenCVForUnity.Utils.getFilePath("noir_santa/noir_santa.1024/texture_0" + i + ".png");
  161.                         }
  162.                         break;
  163.                     }
  164.                 case WhichTexture.uni:
  165.                     {
  166.                         moc_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.moc.bytes");
  167.                         physics_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.physics.json");
  168.                         pose_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.pose.json");
  169.                         for (int i = 0; i < texture_filepath.Length; i++)
  170.                         {
  171.                             texture_filepath[i] = OpenCVForUnity.Utils.getFilePath("uni/uni.1024/texture_0" + i + ".png");
  172.                         }
  173.                         break;
  174.                     }
  175.                 default:
  176.                     {
  177.                         moc_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.moc.bytes");
  178.                         physics_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.physics.json");
  179.                         pose_filepath = OpenCVForUnity.Utils.getFilePath("uni/uni.pose.json");
  180.                         for (int i = 0; i < texture_filepath.Length; i++)
  181.                         {
  182.                             texture_filepath[i] = OpenCVForUnity.Utils.getFilePath("uni/uni.1024/texture_0" + i + ".png");
  183.                         }
  184.                         break;
  185.                     }
  186.             }
  187.  
  188.             live2DModel.textureFiles = new Texture2D[texture_filepath.Length];
  189.             for (int i = 0; i < texture_filepath.Length; i++)
  190.             {
  191.                 if (string.IsNullOrEmpty(texture_filepath[i]))
  192.                     continue;
  193.  
  194.                 Texture2D tex = new Texture2D(2, 2);
  195.                 tex.LoadImage(File.ReadAllBytes(texture_filepath[i]));
  196.                 live2DModel.textureFiles[i] = tex;
  197.             }
  198.             if (!string.IsNullOrEmpty(moc_filepath))
  199.                 live2DModel.setMocFileFromBytes(File.ReadAllBytes(moc_filepath));
  200.             if (!string.IsNullOrEmpty(physics_filepath))
  201.                 live2DModel.setPhysicsFileFromBytes(File.ReadAllBytes(physics_filepath));
  202.             if (!string.IsNullOrEmpty(pose_filepath))
  203.                 live2DModel.setPoseFileFromBytes(File.ReadAllBytes(pose_filepath));
  204.  
  205.         }
  206.  
  207.         private void Run ()
  208.         {
  209.             Debug.Log ("Run");
  210.  
  211.             faceLandmarkDetector = new FaceLandmarkDetector (shape_predictor_68_face_landmarks_dat_filepath);
  212.             frontalFaceParam = new FrontalFaceParam ();
  213.  
  214.             // Use the front camera to Init
  215.             webCamTextureToMatHelper.Init(null, webCamTextureToMatHelper.requestWidth, webCamTextureToMatHelper.requestHeight, !webCamTextureToMatHelper.requestIsFrontFacing);
  216.  
  217.              Default initialization
  218.             //webCamTextureToMatHelper.Init();
  219.             //webCamTextureToMatHelper.Init(null, 320, 240, false);
  220.         }
  221.  
  222.         /// <summary>
  223.         /// Raises the web cam texture to mat helper inited event.
  224.         /// </summary>
  225.         public void OnWebCamTextureToMatHelperInited ()
  226.         {
  227.             Debug.Log ("OnWebCamTextureToMatHelperInited");
  228.  
  229.             Mat webCamTextureMat = webCamTextureToMatHelper.GetMat ();
  230.             
  231.             gameObject.transform.localScale = new Vector3 (webCamTextureMat.cols (), webCamTextureMat.rows (), 1);
  232.  
  233.             Debug.Log ("Screen.width " + Screen.width + " Screen.height " + Screen.height + " Screen.orientation " + Screen.orientation);
  234.  
  235.             float width = gameObject.transform.localScale.x;
  236.             float height = gameObject.transform.localScale.y;
  237.  
  238.             float widthScale = (float)Screen.width / width;
  239.             float heightScale = (float)Screen.height / height;
  240.             if (widthScale < heightScale) {
  241.                 Camera.main.orthographicSize = (width * (float)Screen.height / (float)Screen.width) / 2;
  242.             } else {
  243.                 Camera.main.orthographicSize = height / 2;
  244.             }
  245.  
  246.             if (live2DModel != null) {
  247.                 // Set live2DModel localScale
  248.                 live2DModel.transform.localScale = new Vector3 (Camera.main.orthographicSize * modelScale, Camera.main.orthographicSize * modelScale, 1);
  249.             }
  250.             
  251.         }
  252.  
  253.         /// <summary>
  254.         /// Raises the web cam texture to mat helper disposed event.
  255.         /// </summary>
  256.         public void OnWebCamTextureToMatHelperDisposed ()
  257.         {
  258.             Debug.Log ("OnWebCamTextureToMatHelperDisposed");
  259.  
  260.         }
  261.  
  262.         /// <summary>
  263.         /// Raises the web cam texture to mat helper error occurred event.
  264.         /// </summary>
  265.         public void OnWebCamTextureToMatHelperErrorOccurred ()
  266.         {
  267.             Debug.Log("OnWebCamTextureToMatHelperErrorOccurred");
  268.         }
  269.  
  270.         // Update is called once per frame
  271.         void Update ()
  272.         {
  273.             if (Input.GetKeyDown(KeyCode.Escape))
  274.             {
  275. #if UNITY_5_3 || UNITY_5_3_OR_NEWER
  276.                 SceneManager.LoadScene("FacemojiStart");
  277. #else
  278.                 Application.LoadLevel("FacemojiStart");
  279. #endif
  280.             }
  281.  
  282.             if (webCamTextureToMatHelper.IsPlaying () && webCamTextureToMatHelper.DidUpdateThisFrame ()) {
  283.  
  284.                 Mat rgbaMat = webCamTextureToMatHelper.GetMat();
  285.  
  286.                 OpenCVForUnityUtils.SetImage(faceLandmarkDetector, rgbaMat);
  287.                 //获得特征匹配矩形
  288.  
  289.                 List<UnityEngine.Rect> detectResult = faceLandmarkDetector.Detect ();
  290.  
  291.                 foreach (var rect in detectResult) {
  292.                     //获得68个采样点
  293.                     List<Vector2> points = faceLandmarkDetector.DetectLandmark (rect);
  294.  
  295.                     if (points.Count > 0) {
  296.                         // angle
  297.                         Vector3 angles = frontalFaceParam.getFrontalFaceAngle(points);
  298.                         //初始状态
  299.                         double[,] originState = X_K.Detail;
  300.                         originState[0, 0] = angles.x;
  301.                         originState[1, 0] = angles.y;
  302.                         originState[2, 0] = angles.z;
  303.                         originState[3, 0] = 0;
  304.                         originState[4, 0] = 0;
  305.                         originState[5, 0] = 0;
  306.                         //eye
  307.                         double[,] unit = eye.Detail;
  308.                         unit[0, 0] = 1;
  309.                         unit[0, 1] = 0;
  310.                         unit[0, 2] = 0;
  311.                         unit[0, 3] = 0;
  312.                         unit[0, 4] = 0;
  313.                         unit[0, 5] = 0;
  314.                         unit[1, 0] = 0;
  315.                         unit[1, 1] = 1;
  316.                         unit[1, 2] = 0;
  317.                         unit[1, 3] = 0;
  318.                         unit[1, 4] = 0;
  319.                         unit[1, 5] = 0;
  320.                         unit[2, 0] = 0;
  321.                         unit[2, 1] = 0;
  322.                         unit[2, 2] = 1;
  323.                         unit[2, 3] = 0;
  324.                         unit[2, 4] = 0;
  325.                         unit[2, 5] = 0;
  326.                         unit[3, 0] = 0;
  327.                         unit[3, 1] = 0;
  328.                         unit[3, 2] = 0;
  329.                         unit[3, 3] = 1;
  330.                         unit[3, 4] = 0;
  331.                         unit[3, 5] = 0;
  332.                         unit[4, 0] = 0;
  333.                         unit[4, 1] = 0;
  334.                         unit[4, 2] = 0;
  335.                         unit[4, 3] = 0;
  336.                         unit[4, 4] = 1;
  337.                         unit[4, 5] = 0;
  338.                         unit[5, 0] = 0;
  339.                         unit[5, 1] = 0;
  340.                         unit[5, 2] = 0;
  341.                         unit[5, 3] = 0;
  342.                         unit[5, 4] = 0;
  343.                         unit[5, 5] = 1;
  344.  
  345.  
  346.                         //F_K（F_k）
  347.                         double[,] stateC = F_K.Detail;
  348.                         stateC[0, 0] = 1;
  349.                         stateC[0, 1] = 0;
  350.                         stateC[0, 2] = 0;
  351.                         stateC[0, 3] = 1;
  352.                         stateC[0, 4] = 0;
  353.                         stateC[0, 5] = 0;
  354.                         stateC[1, 0] = 0;
  355.                         stateC[1, 1] = 1;
  356.                         stateC[1, 2] = 0;
  357.                         stateC[1, 3] = 0;
  358.                         stateC[1, 4] = 1;
  359.                         stateC[1, 5] = 0;
  360.                         stateC[2, 0] = 0;
  361.                         stateC[2, 1] = 0;
  362.                         stateC[2, 2] = 1;
  363.                         stateC[2, 3] = 0;
  364.                         stateC[2, 4] = 0;
  365.                         stateC[2, 5] = 1;
  366.                         stateC[3, 0] = 0;
  367.                         stateC[3, 1] = 0;
  368.                         stateC[3, 2] = 0;
  369.                         stateC[3, 3] = 1;
  370.                         stateC[3, 4] = 0;
  371.                         stateC[3, 5] = 0;
  372.                         stateC[4, 0] = 0;
  373.                         stateC[4, 1] = 0;
  374.                         stateC[4, 2] = 0;
  375.                         stateC[4, 3] = 0;
  376.                         stateC[4, 4] = 1;
  377.                         stateC[4, 5] = 0;
  378.                         stateC[5, 0] = 0;
  379.                         stateC[5, 1] = 0;
  380.                         stateC[5, 2] = 0;
  381.                         stateC[5, 3] = 0;
  382.                         stateC[5, 4] = 0;
  383.                         stateC[5, 5] = 1;
  384.  
  385.                         //P_K(P_k)
  386.                         double[,] errCovPost = P_K.Detail;
  387.                         errCovPost[0, 0] = 0.1;
  388.                         errCovPost[0, 1] = 0;
  389.                         errCovPost[0, 2] = 0;
  390.                         errCovPost[0, 3] = 0;
  391.                         errCovPost[0, 4] = 0;
  392.                         errCovPost[0, 5] = 0;
  393.                         errCovPost[1, 0] = 0;
  394.                         errCovPost[1, 1] = 0.1;
  395.                         errCovPost[1, 2] = 0;
  396.                         errCovPost[1, 3] = 0;
  397.                         errCovPost[1, 4] = 0;
  398.                         errCovPost[1, 5] = 0;
  399.                         errCovPost[2, 0] = 0;
  400.                         errCovPost[2, 1] = 0;
  401.                         errCovPost[2, 2] = 0.1;
  402.                         errCovPost[2, 3] = 0;
  403.                         errCovPost[2, 4] = 0;
  404.                         errCovPost[2, 5] = 0;
  405.                         errCovPost[3, 0] = 0;
  406.                         errCovPost[3, 1] = 0;
  407.                         errCovPost[3, 2] = 0;
  408.                         errCovPost[3, 3] = 0.1;
  409.                         errCovPost[3, 4] = 0;
  410.                         errCovPost[3, 5] = 0;
  411.                         errCovPost[4, 0] = 0;
  412.                         errCovPost[4, 1] = 0;
  413.                         errCovPost[4, 2] = 0;
  414.                         errCovPost[4, 3] = 0;
  415.                         errCovPost[4, 4] = 0.1;
  416.                         errCovPost[4, 5] = 0;
  417.                         errCovPost[5, 0] = 0;
  418.                         errCovPost[5, 1] = 0;
  419.                         errCovPost[5, 2] = 0;
  420.                         errCovPost[5, 3] = 0;
  421.                         errCovPost[5, 4] = 0;
  422.                         errCovPost[5, 5] = 0.1;
  423.                         //Debug.Log(MatrixOperator.MatrixPrint(P_K));
  424.  
  425.                         //H_K(H_K)
  426.                         double[,] measureMat = H_K.Detail;
  427.                         measureMat[0, 0] = 1;
  428.                         measureMat[0, 1] = 0;
  429.                         measureMat[0, 2] = 0;
  430.                         measureMat[0, 3] = 0;
  431.                         measureMat[0, 4] = 0;
  432.                         measureMat[0, 5] = 0;
  433.                         measureMat[1, 0] = 0;
  434.                         measureMat[1, 1] = 1;
  435.                         measureMat[1, 2] = 0;
  436.                         measureMat[1, 3] = 0;
  437.                         measureMat[1, 4] = 0;
  438.                         measureMat[1, 5] = 0;
  439.                         measureMat[2, 0] = 0;
  440.                         measureMat[2, 1] = 0;
  441.                         measureMat[2, 2] = 1;
  442.                         measureMat[2, 3] = 0;
  443.                         measureMat[2, 4] = 0;
  444.                         measureMat[2, 5] = 0;
  445.  
  446.                         //Q_K(Q_K)
  447.                         double[,] processNoiseCov = Q_K.Detail;
  448.                         processNoiseCov[0, 0] = 1;
  449.                         processNoiseCov[0, 1] = 0;
  450.                         processNoiseCov[0, 2] = 0;
  451.                         processNoiseCov[0, 3] = 0;
  452.                         processNoiseCov[0, 4] = 0;
  453.                         processNoiseCov[0, 5] = 0;
  454.                         processNoiseCov[1, 0] = 0;
  455.                         processNoiseCov[1, 1] = 1;
  456.                         processNoiseCov[1, 2] = 0;
  457.                         processNoiseCov[1, 3] = 0;
  458.                         processNoiseCov[1, 4] = 0;
  459.                         processNoiseCov[1, 5] = 0;
  460.                         processNoiseCov[2, 0] = 0;
  461.                         processNoiseCov[2, 1] = 0;
  462.                         processNoiseCov[2, 2] = 1;
  463.                         processNoiseCov[2, 3] = 0;
  464.                         processNoiseCov[2, 4] = 0;
  465.                         processNoiseCov[2, 5] = 0;
  466.                         processNoiseCov[3, 0] = 0;
  467.                         processNoiseCov[3, 1] = 0;
  468.                         processNoiseCov[3, 2] = 0;
  469.                         processNoiseCov[3, 3] = 1;
  470.                         processNoiseCov[3, 4] = 0;
  471.                         processNoiseCov[3, 5] = 0;
  472.                         processNoiseCov[4, 0] = 0;
  473.                         processNoiseCov[4, 1] = 0;
  474.                         processNoiseCov[4, 2] = 0;
  475.                         processNoiseCov[4, 3] = 0;
  476.                         processNoiseCov[4, 4] = 1;
  477.                         processNoiseCov[4, 5] = 0;
  478.                         processNoiseCov[5, 0] = 0;
  479.                         processNoiseCov[5, 1] = 0;
  480.                         processNoiseCov[5, 2] = 0;
  481.                         processNoiseCov[5, 3] = 0;
  482.                         processNoiseCov[5, 4] = 0;
  483.                         processNoiseCov[5, 5] = 1;
  484.  
  485.                         //R_K(R_K)
  486.                         double[,] measureNoiseCov = R_K.Detail;
  487.                         measureNoiseCov[0, 0] = 0.03;
  488.                         measureNoiseCov[0, 1] = 0;
  489.                         measureNoiseCov[0, 2] = 0;
  490.                         measureNoiseCov[1, 0] = 0;
  491.                         measureNoiseCov[1, 1] = 0.03;
  492.                         measureNoiseCov[1, 2] = 0;
  493.                         measureNoiseCov[2, 0] = 0;
  494.                         measureNoiseCov[2, 1] = 0;
  495.                         measureNoiseCov[2, 2] = 0.03;
  496.  
  497.                         double[] Arr = new double[] { angles.x, angles.y, angles.z};
  498.                         //X_0 初始状态
  499.                         double[,] measure = Z_K.Detail;
  500.                         measure[0, 0] = Arr[0];
  501.                         measure[1, 0] = Arr[1];
  502.                         measure[2, 0] = Arr[2];
  503.  
  504.                         //首先计算推测值
  505.                         Matrix X_front = MatrixOperator.MatrixMulti(F_K, X_K);
  506.                         //然后计算推测值与真实值之间的误差协方差矩阵
  507.                         Matrix P_front = MatrixOperator.MatrixMulti(MatrixOperator.MatrixMulti(MatrixOperator.MatrixMulti(F_K, P_K), MatrixOperator.MatrixTrans(F_K)), Q_K);
  508.                         //再计算卡尔曼增益
  509.                         Matrix Kg = MatrixOperator.MatrixMulti(MatrixOperator.MatrixMulti(P_front, MatrixOperator.MatrixTrans(H_K)), MatrixOperator.MatrixInv(MatrixOperator.MatrixAdd(MatrixOperator.MatrixMulti(MatrixOperator.MatrixMulti(H_K, P_front), MatrixOperator.MatrixTrans(H_K)), R_K)));
  510.  
  511.                         //再得到估计值
  512.                         Matrix X_front_ = MatrixOperator.MatrixAdd(X_front, MatrixOperator.MatrixMulti(Kg, MatrixOperator.MatrixSub(Z_K, MatrixOperator.MatrixMulti(H_K, X_front))));
  513.                         //最后计算估计值与真实值之间的误差协方差矩阵，为下次递推做准备
  514.                         Matrix P_front_ = MatrixOperator.MatrixMulti(MatrixOperator.MatrixSub(eye, MatrixOperator.MatrixMulti(Kg, H_K)), P_front);
  515.                         X_K = X_front_;
  516.                         P_K = P_front_;
  517.                         double[,] c = X_K.Detail;
  518.                         double aa = c[0, 0];
  519.                         double bb = c[1,0];
  520.                         double  cc = c[2, 0];
  521.                         angles.x = (int)aa;
  522.                         angles.y = (int)bb;
  523.                         angles.z = (int)cc;
  524.  
  525.                         float rotateX = (angles.x > 180) ? angles.x - 360 : angles.x;
  526.                         float rotateY = (angles.y > 180) ? angles.y - 360 : angles.y;
  527.                         float rotateZ = (angles.z > 180) ? angles.z - 360 : angles.z;
  528.                         // Coordinate transformation
  529.                         //live2DModel.PARAM_ANGLE.Set(-rotateY, rotateX, -rotateZ);
  530.                         live2DModel.PARAM_ANGLE.Set(rotateX, rotateY, rotateZ);
  531.  
  532.                         // Make sure your line of sight is always facing the camera
  533.                         // eye_ball_X
  534.                         live2DModel.PARAM_EYE_BALL_X = rotateX / 60f;
  535.                         // eye_ball_Y
  536.                         live2DModel.PARAM_EYE_BALL_Y = rotateY / 60f - 0.25f;
  537.  
  538.                         live2DModelUpdate (points);
  539.  
  540.                         break;
  541.                     }
  542.                 }
  543.             }
  544.  
  545.         }
  546.  
  547.         private void live2DModelUpdate (List<Vector2> points)
  548.         {
  549.  
  550.             if (live2DModel != null) {
  551.  
  552.  
  553.                 //live2DModel.PARAM_ANGLE.Set(-Roundf(rotateY, 0.5f), Roundf(rotateX, 0.5f), -Roundf(rotateZ, 0.5f));
  554.  
  555.                 // brow_L_Y
  556.                 float brow_L_Y = getRaitoOfBROW_L_Y(points);
  557.                 // Keep three decimal places to reduce the vibration
  558.                 live2DModel.PARAM_BROW_L_Y = Roundf(brow_L_Y, 1000f);
  559.                 //live2DModel.PARAM_BROW_L_Y = (float)Math.Round(brow_L_Y, 2);
  560.  
  561.                 // brow_R_Y
  562.                 float brow_R_Y = getRaitoOfBROW_R_Y(points);
  563.                 // Keep three decimal places to reduce the vibration
  564.                 live2DModel.PARAM_BROW_R_Y = Roundf(brow_R_Y, 1000f);
  565.                 //live2DModel.PARAM_BROW_R_Y = (float)Math.Round(brow_R_Y, 2);
  566.  
  567.                 // eye_open_L
  568.                 float eyeOpen_L = getRaitoOfEyeOpen_L (points);
  569.                 if (eyeOpen_L > 0.6f && eyeOpen_L < 1.1f)
  570.                     eyeOpen_L = 1;
  571.                 else if (eyeOpen_L >= 1.1f && brow_L_Y >= 0 )
  572.                     eyeOpen_L = 2;
  573.                 else if (eyeOpen_L <= 0.6f)
  574.                     eyeOpen_L = 0;
  575.                 live2DModel.PARAM_EYE_L_OPEN = eyeOpen_L;
  576.  
  577.                 // eye_open_R
  578.                 float eyeOpen_R = getRaitoOfEyeOpen_R (points);
  579.                 if (eyeOpen_R > 0.6f && eyeOpen_R < 1.1f)
  580.                     eyeOpen_R = 1;
  581.                 else if (eyeOpen_R >= 1.1f && brow_R_Y >= 0)
  582.                     eyeOpen_R = 2;
  583.                 else if (eyeOpen_R < 0.6f)
  584.                     eyeOpen_R = 0;
  585.                 live2DModel.PARAM_EYE_R_OPEN = eyeOpen_R;
  586.  
  587.  
  588.  
  589.                 // mouth_open
  590.                 float mouthOpen = getRaitoOfMouthOpen_Y (points);
  591.                 if (mouthOpen < 0.6f)
  592.                     mouthOpen = 0;
  593.                 live2DModel.PARAM_MOUTH_OPEN_Y = mouthOpen;
  594.  
  595.                 // mouth_size
  596.                 float mouthSize = getRaitoOfMouthSize (points);
  597.                 live2DModel.PARAM_MOUTH_SIZE = mouthSize;
  598.  
  599.             }
  600.         }
  601.  
  602.         // Keep decimal places to reduce the vibration
  603.         private float Roundf(float f, float multiple)
  604.         {
  605.             if (multiple == 0)
  606.                 return f;
  607.             int i = (int)(f * multiple);
  608.             return i / multiple;
  609.         }
  610.  
  611.         // Calculate the degree of eye opening
  612.         private float getRaitoOfEyeOpen_L (List<Vector2> points)
  613.         {
  614.             if (points.Count != 68)
  615.                 throw new ArgumentNullException ("Invalid landmark_points.");
  616.  
  617.             return Mathf.Clamp (Mathf.Abs (points [43].y - points [47].y) / (Mathf.Abs (points [43].x - points [44].x) * 0.75f), -0.1f, 2.0f);
  618.         }
  619.  
  620.         private float getRaitoOfEyeOpen_R (List<Vector2> points)
  621.         {
  622.             if (points.Count != 68)
  623.                 throw new ArgumentNullException ("Invalid landmark_points.");
  624.  
  625.             return Mathf.Clamp (Mathf.Abs (points [38].y - points [40].y) / (Mathf.Abs (points [37].x - points [38].x) * 0.75f), -0.1f, 2.0f);
  626.         }
  627.  
  628.         // Eyebrows move up and down
  629.         private float getRaitoOfBROW_L_Y (List<Vector2> points)
  630.         {
  631.             if (points.Count != 68)
  632.                 throw new ArgumentNullException ("Invalid landmark_points.");
  633.  
  634.             //float y = Mathf.Ceil(Mathf.Abs(points[24].y - points[27].y)) / Mathf.Abs (points [27].y - points [29].y);
  635.             float y = Mathf.Abs(points[24].y - points[27].y) / Mathf.Abs(points[27].y - points[29].y);
  636.             y -= 1;
  637.             y *= 4f;
  638.             
  639.             return Mathf.Clamp (y, -1.0f, 1.0f);
  640.         }
  641.  
  642.         private float getRaitoOfBROW_R_Y (List<Vector2> points)
  643.         {
  644.             if (points.Count != 68)
  645.                 throw new ArgumentNullException ("Invalid landmark_points.");
  646.  
  647.             //float y = Mathf.Ceil(Mathf.Abs(points[19].y - points[27].y)) / Mathf.Abs(points[27].y - points[29].y);
  648.             float y = Mathf.Abs(Mathf.Sqrt(Mathf.Pow(points[19].y - points[27].y,2)+Mathf.Pow(points[19].x - points[27].x,2))) / Mathf.Abs(Mathf.Sqrt(Mathf.Pow(points[27].y - points[29].y,2)+Mathf.Pow(points[27].x - points[29].x,2))) ;
  649.             Debug.Log("y是："+y);
  650.             y -= 1;
  651.             y *= 4f;
  652.  
  653.             return Mathf.Clamp (y, -1.0f, 1.0f);
  654.         }
  655.  
  656.         // Calculate the degree of mouth opening
  657.         private float getRaitoOfMouthOpen_Y (List<Vector2> points)
  658.         {
  659.             if (points.Count != 68)
  660.                 throw new ArgumentNullException ("Invalid landmark_points.");
  661.  
  662.             return (float)((points[57].y - points[51].y) / (points[64].x - points[60].x) - 0.2);
  663.  
  664.             //return Mathf.Clamp01 (Mathf.Abs (points [62].y - points [66].y) / (Mathf.Abs (points [51].y - points [62].y) + Mathf.Abs (points [66].y - points [57].y)));
  665.         }
  666.  
  667.         // Calculate the width of the mouth
  668.         private float getRaitoOfMouthSize (List<Vector2> points)
  669.         {
  670.             if (points.Count != 68)
  671.                 throw new ArgumentNullException ("Invalid landmark_points.");
  672.  
  673.             float size = Mathf.Abs (points [48].x - points [54].x) / (Mathf.Abs (points [31].x - points [35].x) * 1.8f);
  674.             size -= 1;
  675.             size *= 4f;
  676.  
  677.             return Mathf.Clamp (size, -1.0f, 1.0f);
  678.         }
  679.  
  680.         /// <summary>
  681.         /// Raises the disable event.
  682.         /// </summary>
  683.         void OnDisable ()
  684.         {
  685.             if(webCamTextureToMatHelper != null) webCamTextureToMatHelper.Dispose ();
  686.  
  687.             if(faceLandmarkDetector != null) faceLandmarkDetector.Dispose ();
  688.  
  689.             if(frontalFaceParam != null) frontalFaceParam.Dispose ();
  690.         }
  691.  
  692.         public void OnBackButton()
  693.         {
  694. #if UNITY_5_3 || UNITY_5_3_OR_NEWER
  695.             SceneManager.LoadScene("FacemojiStart");
  696. #else
  697.             Application.LoadLevel("FacemojiStart");
  698. #endif
  699.         }
  700.  
  701.         /// <summary>
  702.         /// Raises the change camera button event.
  703.         /// </summary>
  704.         public void OnChangeCameraButton ()
  705.         {
  706.             webCamTextureToMatHelper.Init (null, webCamTextureToMatHelper.requestWidth, webCamTextureToMatHelper.requestHeight, !webCamTextureToMatHelper.requestIsFrontFacing);
  707.         }
  708.  
  709.         public void OnStartButton()
  710.         {
  711.             startBtn.SetActive(false);
  712.             if (!Record.isRecording)
  713.             {
  714.                 //Start recording
  715.                 Record.isRecording = true;
  716.                 finishBtn.SetActive(true);
  717.             }
  718.         }
  719.  
  720.         public void OnFinishButton()
  721.         {
  722.             finishBtn.SetActive(false);
  723.             if (Record.isRecording)
  724.             {
  725.                 //Finish recording
  726.                 Record.isRecording = false;
  727.                 startBtn.SetActive(true);
  728.             }
  729.         }
  730.  
  731.         public void OnShizukuButton()
  732.         {
  733.             if(selectedTexture != WhichTexture.noir_santa)
  734.             {
  735.                 selectedTexture = WhichTexture.noir_santa;
  736.                 LoadTexture();
  737.             }
  738.         }
  739.  
  740.         public void OnHaruButton()
  741.         {
  742.             if (selectedTexture != WhichTexture.uni)
  743.             {
  744.                 selectedTexture = WhichTexture.uni;
  745.                 LoadTexture();
  746.             }
  747.         }
  748.  
  749.     }
  750. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/123020
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号