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

第18届全国大学生智能汽车竞赛四轮车开源讲解【3】--边线提取_第18届全国大学生智汽车竞赛四轮

作者：Monodyee | 2024-03-14 18:39:06

赞

踩

第18届全国大学生智汽车竞赛四轮

开源汇总写在下面

第18届全国大学生智能汽车竞赛四轮车开源讲解_Joshua.X的博客-CSDN博客

一、巡线/找边界

当摄像头成功获取一帧图像，并且预处理（二值化）之后，我们最重要的事情就是获取赛道信息。其中最基本的就是赛道编边界信息，左边，右边，中线等基础数据。

事先声明，没有那种算法是完美的，只要算法能够得到足够多想要的信息，那么他就是好算法。

不同算法之间没有优劣之分，多少国赛选手仍跑着最简单的算法，这并不影响什么。

1.(双)最长白列

首先介绍我使用的（双）最长白列法。

首先获取到一张二值化图像，那么我先从最下面一列，对于每一列向上寻找白点，同时计数，遇到停止黑点就停止。

示意图如下：

从左往右，从下往上寻找白点计数，遇到黑点就停止

最长白列寻找代码如下

  1. volatile int White_Column[MT9V03X_W];//每列白列长度
  2.  
  3. //从左到右，从下往上，遍历全图记录范围内的每一列白点数量
  4. for (j =start_column; j<=end_column; j++)
  5. {
  6.     for (i = MT9V03X_H - 1; i >= 0; i--)
  7.     {
  8.         if(image_two_value[i][j] == IMG_BLACK)
  9.             break;
  10.         else
  11.             White_Column[j]++;
  12.     }
  13. }

这样我们就得到了每一列连续白点的个数分布直方数据。

随后，从左到右寻找白点数量最多的一列；同样的，从右到左也寻找白点数最多的一列。

有些同学可能会疑惑，既然是最多，那么只有一个，为什么要从左往右找，再从右往左找呢？

这其实不矛盾，同样是最多，有可能都是整幅图像的高，但是位置有可能一不样。参考上方的图。

参考代码如下：

  1. //从左到右找左边最长白列
  2.     Longest_White_Column_Left[0] =0;
  3.     for(i=start_column;i<=end_column;i++)
  4.     {
  5.         if (Longest_White_Column_Left[0] < White_Column[i])//找最长的那一列
  6.         {
  7.             Longest_White_Column_Left[0] = White_Column[i];//【0】是白列长度
  8.             Longest_White_Column_Left[1] = i;              //【1】是下标，第j列
  9.         }
  10.     }
  11.     //从右到左找右左边最长白列
  12.     Longest_White_Column_Right[0] = 0;//【0】是白列长度
  13.     for(i=end_column;i>=start_column;i--)//从右往左，注意条件，找到左边最长白列位置就可以停了
  14.     {
  15.         if (Longest_White_Column_Right[0] < White_Column[i])//找最长的那一列
  16.         {
  17.             Longest_White_Column_Right[0] = White_Column[i];//【0】是白列长度
  18.             Longest_White_Column_Right[1] = i;              //【1】是下标，第j列
  19.         }
  20.     }

到这里我们已经找到了左最长白列，右最长白列，这两个值理论上是一样的，都是规定范围内的最长白列的长度值。

这个值还有一个名字，叫搜索截止行，做元素判断时非常有用，因为他代表了我们的视野，最长白列越长，说明我们看到越远，我们面前越有可能是直道，反之面前大概率是弯道。

    Search_Stop_Line = Longest_White_Column_Left[0];//搜索截止行选取左或者右区别不大，他们两个理论上是一样的
直道与弯道最长白列位置与长度的区别可以用来判断直道弯道

接下来就可以找边界了，从图像最下一行开始，到截止行结束。

从左最长白列向左找，找到"黑黑白"，即白点为左边界；

从右最长白列向右找，找到“白黑黑”，即白点为右边界。

当找到图像的边界仍然没有找到赛道边界，认为丢线，将屏幕边界放到赛道边界。如上图右下角即为丢线。

参考代码如下：

  1.    //相关数据使用前清零
  2.     Longest_White_Column_Left[0] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  3.     Longest_White_Column_Left[1] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  4.     Longest_White_Column_Right[0] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  5.     Longest_White_Column_Right[1] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  6.     for (i = MT9V03X_H - 1; i >=MT9V03X_H-Search_Stop_Line; i--)//常规巡线
  7.     {//从最下面一行，访问到我的有效是视野行
  8.         for (j = Longest_White_Column_Right[1]; j <= MT9V03X_W - 1 - 2; j++)
  9.         {
  10.             if (image_two_value[i][j] ==IMG_WHITE && image_two_value[i][j + 1] == IMG_BLACK && image_two_value[i][j + 2] == IMG_BLACK)//白黑黑，找到右边界
  11.             {
  12.                 right_border = j;
  13.                 Right_Lost_Flag[i] = 0; //右丢线数组，丢线置1，不丢线置0
  14.                 break;
  15.             }
  16.             else if(j>=MT9V03X_W-1-2)//没找到右边界，把屏幕最右赋值给右边界
  17.             {
  18.                 right_border = j;
  19.                 Right_Lost_Flag[i] = 1; //右丢线数组，丢线置1，不丢线置0
  20.                 break;
  21.             }
  22.         }
  23.         for (j = Longest_White_Column_Left[1]; j >= 0 + 2; j--)//往左边扫描
  24.         {//从最下面一行，访问到我的有效是视野行
  25.             if (image_two_value[i][j] ==IMG_WHITE && image_two_value[i][j - 1] == IMG_BLACK && image_two_value[i][j - 2] == IMG_BLACK)//黑黑白认为到达左边界
  26.             {
  27.                 left_border = j;
  28.                 Left_Lost_Flag[i] = 0; //左丢线数组，丢线置1，不丢线置0
  29.                 break;
  30.             }
  31.             else if(j<=0+2)
  32.             {
  33.                 left_border = j;//找到头都没找到边，就把屏幕最左右当做边界
  34.                 Left_Lost_Flag[i] = 1; //左丢线数组，丢线置1，不丢线置0
  35.                 break;
  36.             }
  37.         }
  38.         Left_Line [i] = left_border;       //左边线线数组
  39.         Right_Line[i] = right_border;      //右边线线数组
  40.     }

需要注意的是，在对（i，j）坐标进行边界判断时，会访问到他相邻的（i，j+1）,（i，j+2）或者（i，j-1）,（i，j-2），故需要对j的范围进行限制，限制在（0+2，MT9V03X_W- 1- 2）这个范围中，保证访问时不会数组越界。

还有一点，最长白列Search_Stop_Line代表着图像视野，但是只代表视野的长度，当进行坐标访问时，需要进行换算。换算方式为：MT9V03X_H-Search_Stop_Line；

例如，下方图视野为满，也就是我图像高70，，那我们访问到视野顶端时，需要计算

MT9V03X_H-Search_Stop_Line=70-70=0；

也就是我可以从第MT9V03X_H-1行访问到第0行，这都是我的有效视野。

(双)最长白列示意图

搜索边界到搜所截止行就不往下搜也是有原因的，就像下面的图，在截止行外仍让有图像，如果一直搜下去，不知道他会找到什么地方作为边界，这样影响后续控制。

这张图在有效视野外仍有图像，但不能使用

 有效视野是区别赛道信息有效性的一大判断条件。当然，最长白列巡线也有一定的bug。看下图。

最长白列的bug

 这是一张弯道斜入十字的图，由于最长白列出现的位置比较巧，边界就找错了，出现了边界线往回跑的现象，这就需要我们对最长白列出现的位置进行限制。

  1.     int start_column=20;//最长白列的搜索区间
  2.     int end_column=MT9V03X_W-20;

这里就限制住了最长白列不会出现在图像的两边20像素之内，防止了上述情况的发生。当然，具体情况需要根据车子实际视野来定。

这里简单说一下，（双）最长白列为什么要将双用括号括起来。

因为双最长白列使用效果和单最长白列一样，只是减少了一点点左右巡边的时间。如果只找一边的最长白列，那就从最长白列向左找左边界，向右找右边界。最长白列的长度仍是搜索截止行。

完整参考代码如下

  1. /*-------------------------------------------------------------------------------------------------------------------
  2.   @brief     双最长白列巡线
  3.   @param     null
  4.   @return    null
  5.   Sample     Longest_White_Column_Left();
  6.   @note      最长白列巡线，寻找初始边界，丢线，最长白列等基础元素，后续读取这些变量来进行赛道识别
  7. -------------------------------------------------------------------------------------------------------------------*/
  8. void Longest_White_Column()//最长白列巡线
  9. {
  10.     int i, j;
  11.     int start_column=20;//最长白列的搜索区间
  12.     int end_column=MT9V03X_W-20;
  13.     int left_border = 0, right_border = 0;//临时存储赛道位置
  14.     Longest_White_Column_Left[0] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  15.     Longest_White_Column_Left[1] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  16.     Longest_White_Column_Right[0] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  17.     Longest_White_Column_Right[1] = 0;//最长白列,[0]是最长白列的长度，[1】是第某列
  18.     Right_Lost_Time = 0;    //边界丢线数
  19.     Left_Lost_Time  = 0;
  20.     Boundry_Start_Left  = 0;//第一个非丢线点,常规边界起始点
  21.     Boundry_Start_Right = 0;
  22.     Both_Lost_Time = 0;//两边同时丢线数
  23.  
  24.     for (i = 0; i <=MT9V03X_H-1; i++)//数据清零
  25.     {
  26.         Right_Lost_Flag[i] = 0;
  27.         Left_Lost_Flag[i] = 0;
  28.         Left_Line[i] = 0;
  29.         Right_Line[i] = MT9V03X_W-1;
  30.     }
  31.     for(i=0;i<=MT9V03X_W-1;i++)
  32.     {
  33.         White_Column[i] = 0;
  34.     }
  35.  
  36. //环岛需要对最长白列范围进行限定
  37.     //环岛3状态需要改变最长白列寻找范围
  38.     if(Right_Island_Flag==1)//右环
  39.     {
  40.         if(Island_State==3)
  41.         {
  42.             start_column=40;
  43.             end_column=MT9V03X_W-20;
  44.         }
  45.     }
  46.     else if(Left_Island_Flag==1)//左环
  47.     {
  48.         if(Island_State==3)
  49.         {
  50.             start_column=20;
  51.             end_column=MT9V03X_W-40;
  52.         }
  53.     }
  54.  
  55.     //从左到右，从下往上，遍历全图记录范围内的每一列白点数量
  56.     for (j =start_column; j<=end_column; j++)
  57.     {
  58.         for (i = MT9V03X_H - 1; i >= 0; i--)
  59.         {
  60.             if(image_two_value[i][j] == IMG_BLACK)
  61.                 break;
  62.             else
  63.                 White_Column[j]++;
  64.         }
  65.     }
  66.  
  67.     //从左到右找左边最长白列
  68.     Longest_White_Column_Left[0] =0;
  69.     for(i=start_column;i<=end_column;i++)
  70.     {
  71.         if (Longest_White_Column_Left[0] < White_Column[i])//找最长的那一列
  72.         {
  73.             Longest_White_Column_Left[0] = White_Column[i];//【0】是白列长度
  74.             Longest_White_Column_Left[1] = i;              //【1】是下标，第j列
  75.         }
  76.     }
  77.     //从右到左找右左边最长白列
  78.     Longest_White_Column_Right[0] = 0;//【0】是白列长度
  79.     for(i=end_column;i>=start_column;i--)//从右往左，注意条件，找到左边最长白列位置就可以停了
  80.     {
  81.         if (Longest_White_Column_Right[0] < White_Column[i])//找最长的那一列
  82.         {
  83.             Longest_White_Column_Right[0] = White_Column[i];//【0】是白列长度
  84.             Longest_White_Column_Right[1] = i;              //【1】是下标，第j列
  85.         }
  86.     }
  87.  
  88.     Search_Stop_Line = Longest_White_Column_Left[0];//搜索截止行选取左或者右区别不大，他们两个理论上是一样的
  89.     for (i = MT9V03X_H - 1; i >=MT9V03X_H-Search_Stop_Line; i--)//常规巡线
  90.     {
  91.         for (j = Longest_White_Column_Right[1]; j <= MT9V03X_W - 1 - 2; j++)
  92.         {
  93.             if (image_two_value[i][j] ==IMG_WHITE && image_two_value[i][j + 1] == IMG_BLACK && image_two_value[i][j + 2] == IMG_BLACK)//白黑黑，找到右边界
  94.             {
  95.                 right_border = j;
  96.                 Right_Lost_Flag[i] = 0; //右丢线数组，丢线置1，不丢线置0
  97.                 break;
  98.             }
  99.             else if(j>=MT9V03X_W-1-2)//没找到右边界，把屏幕最右赋值给右边界
  100.             {
  101.                 right_border = j;
  102.                 Right_Lost_Flag[i] = 1; //右丢线数组，丢线置1，不丢线置0
  103.                 break;
  104.             }
  105.         }
  106.         for (j = Longest_White_Column_Left[1]; j >= 0 + 2; j--)//往左边扫描
  107.         {
  108.             if (image_two_value[i][j] ==IMG_WHITE && image_two_value[i][j - 1] == IMG_BLACK && image_two_value[i][j - 2] == IMG_BLACK)//黑黑白认为到达左边界
  109.             {
  110.                 left_border = j;
  111.                 Left_Lost_Flag[i] = 0; //左丢线数组，丢线置1，不丢线置0
  112.                 break;
  113.             }
  114.             else if(j<=0+2)
  115.             {
  116.                 left_border = j;//找到头都没找到边，就把屏幕最左右当做边界
  117.                 Left_Lost_Flag[i] = 1; //左丢线数组，丢线置1，不丢线置0
  118.                 break;
  119.             }
  120.         }
  121.         Left_Line [i] = left_border;       //左边线线数组
  122.         Right_Line[i] = right_border;      //右边线线数组
  123.     }
  124.  
  125.     for (i = MT9V03X_H - 1; i >= 0; i--)//赛道数据初步分析
  126.     {
  127.         if (Left_Lost_Flag[i]  == 1)//单边丢线数
  128.             Left_Lost_Time++;
  129.         if (Right_Lost_Flag[i] == 1)
  130.             Right_Lost_Time++;
  131.         if (Left_Lost_Flag[i] == 1 && Right_Lost_Flag[i] == 1)//双边丢线数
  132.             Both_Lost_Time++;
  133.         if (Boundry_Start_Left ==  0 && Left_Lost_Flag[i]  != 1)//记录第一个非丢线点，边界起始点
  134.             Boundry_Start_Left = i;
  135.         if (Boundry_Start_Right == 0 && Right_Lost_Flag[i] != 1)
  136.             Boundry_Start_Right = i;
  137.         Road_Wide[i]=Right_Line[i]-Left_Line[i];
  138.     }
  139.  
  140.     //环岛3状态改变边界，看情况而定，我认为理论上的最优情况是不需要这些处理的
  141.     if(Island_State==3||Island_State==4)
  142.     {
  143.         if(Right_Island_Flag==1)//右环
  144.         {
  145.             for (i = MT9V03X_H - 1; i >= 0; i--)//右边直接写在边上
  146.             {
  147.                 Right_Line[i]=MT9V03X_W-1;
  148.             }
  149.         }
  150.         else if(Left_Island_Flag==1)//左环
  151.         {
  152.             for (i = MT9V03X_H - 1; i >= 0; i--)//左边直接写在边上
  153.             {
  154.                 Left_Line[i]=0;      //右边线线数组
  155.             }
  156.         }
  157.     }
  158.     //debug使用，屏幕显示相关参数
  159. //    ips200_showint16(0,0, Longest_White_Column_Right[0]);//【0】是白列长度
  160. //    ips200_showint16(0,1, Longest_White_Column_Right[1]);//【1】是下标，第j列)
  161. //    ips200_showint16(0,2, Longest_White_Column_Left[0]);//【0】是白列长度
  162. //    ips200_showint16(0,3, Longest_White_Column_Left[1]);//【1】是下标，第j列)
  163. }

2.常规巡线

常规巡线是我17届智能车比赛时使用的，核心想法与最长白列差不多，起始点的处理有所不同，这里简单讲下。

首先在图像最下一行进行判断搜索起始点，默认是图像中间，如果是图像中间是黑的话，那就判断图像左1/4处是不是黑，右1/4处是不是黑，这样找到一个搜索起始点，从起始点开始，向左向右进行判断。同样的“黑黑白”白点是左边界，“白黑黑”白点是右边界，左加右除以2，计算出当前的中线位置，下一次的起始点是这一次的中点，就这样断搜下去，也叫“中线继承法”，同样可以找到边线。

先进行起始点判断，再进行中线继承巡边

 这也是一种可行的办法，参考代码如下：

  1. /*
  2.  * 从下往上巡线，从中巡间往两边线
  3.  */
  4. void Find_Boundry(void)//从中间往两边搜索中线
  5. {
  6.     int i,j;
  7.     static int left_border=0,right_border=0,mid=MT9V03X_W/2,last_mid=MT9V03X_W/2;
  8.     right_line_lost=0;
  9.     left_line_lost=0;.
  10.     //起始点合理性判断
  11.     if(image_two_value[MT9V03X_H-1][MT9V03X_W/2]==0x00)//屏幕中线是黑的话
  12.     {
  13.         if(image_two_value[MT9V03X_H-1][MT9V03X_W/4]==0xff)//看看左1/4是不是白
  14.         {
  15.             last_mid=MT9V03X_W/4;//更改搜索起始点
  16.         }
  17.         else if(image_two_value[MT9V03X_H-1][MT9V03X_W/4*3]==0xff)//看看右1/4是不是白
  18.         {
  19.             last_mid=MT9V03X_W/4*3;//更改搜索起始点
  20.         }
  21.     }
  22.     //开始巡边
  23.     for(i=MT9V03X_H-1;i>=0;i--)//从最底下往上扫描
  24.     {
  25.         for(j=last_mid;j<MT9V03X_W-3;j++)//往右扫描
  26.         {
  27.             if(image_two_value[i][j]==0xff&&image_two_value[i][j+1]==0x00&&image_two_value[i][j+2]==0x00)//白黑黑，找到右边界
  28.             {
  29.                 right_border=j;
  30.                 Right_Lost_Flag[i]=0; //右丢线数组，丢线置1，不丢线置0
  31.                 break;//跳出，找到本行边界就没必要循环下去了
  32.             }
  33.             else
  34.             {
  35.                 right_border=j;//没找到右边界，把屏幕最右赋值给右边界
  36.                 Right_Lost_Flag[i]=1; //右丢线数组，丢线置1，不丢线置0
  37.             }
  38.         }
  39.         right_line_lost+=Right_Lost_Flag[i];
  40.         for(j=last_mid;j>1;j--)//往左边扫描
  41.         {
  42.             if(image_two_value[i][j]==0xff&&image_two_value[i][j-1]==0x00&&image_two_value[i][j-2]==0x00)//黑黑白认为到达左边界
  43.             {
  44.                 left_border=j;
  45.                 Left_Lost_Flag[i]=0; //左丢线数组，丢线置1，不丢线置0
  46.                 break;//跳出，找到本行边界就没必要循环下去了
  47.             }
  48.             else
  49.             {
  50.                 left_border=j;//找到头都没找到边，就把屏幕最左右当做边界
  51.                 Left_Lost_Flag[i]=1; //左丢线数组，丢线置1，不丢线置0
  52.             }
  53.         }
  54.         left_line_lost+=Left_Lost_Flag[i];
  55.         mid=(left_border+right_border)/2;//中线坐标
  56.         last_mid=mid;//中线查找开始点，方便下一次找中线
  57.         Left_Line [i]= left_border ;      //左边线线数组
  58.         Right_Line[i]= right_border;      //右边线线数组
  59.         Road_Wide[i]=Right_Line[i]-Left_Line [i];
  60.     }
  61. }

3.八邻域

八邻域呢是智能车处理的一大热门话题，他可以以超快的速度处理出图像的边缘，我称之为“爬线”，因为只要起始点正确，他可以沿着图像的边缘（赛道边缘）快速爬出整条边界。

其中有灰度八邻域，二值化八邻域，核心原理都差不多，以当前点为中心，开一个九宫格，去看附近的格子变化趋势如何，找到下一个点，再以下一个点为中心，开九宫格，判断在下一个点的情况，如此类推，沿着边线爬完全图。

八邻域原理

八邻域搜线图示来自b站大佬:AI云归

 具体的操作，建议参考b站大佬：AI云归，他开源了很多资料，大家可以前去学习

但是八邻域在智能车方面需要有不少限制，不然可能会爬到某个怪圈里面，把自己死卡，出不来。

4.逆透视

逆透视是好多大佬使用的方法，核心原理就是坐标系的转化，让一张图片从智能车视角，转化为上帝视角，这样有好处，赛道还原度可以非常高，并且在一些角点，弯道，可以进行角度，甚至是曲率的计算，非常有利于元素的处理。

智能车视角的十字回环

逆透视处理后看到的十字回环

关于逆透视方面，需要借助MATLAB工具进行标定，测量等，前期需要做一些准备工作，但是一但标定完成，使用起来效果还是很高端的。

关于逆透视方面，大家可以参考上交AuTop开源，以及b站大佬：__苏格拉没有底___，他们的开源，讲的很多很好。

5.迷宫法

迷宫法巡线是上交开源出的一套巡线法，在开源之后广受好评，大家也可参考

第16届智能车智能视觉组-上海交通大学AuTop战队开源汇总 - 知乎

二、赛道基本信息

1.标准赛道宽度

  1. const uint8 Standard_Road_Wide[MT9V03X_H]=//标准赛宽
  2. { 10, 12, 14, 16, 18, 20, 22, 24, 26, 28,
  3.   30, 32, 34, 36, 38, 40, 42, 44, 46, 48,
  4.   50, 52, 54, 56, 58, 60, 62, 64, 66, 68,
  5.   70, 72, 74, 76, 78, 80, 82, 84, 86, 88,
  6.   90, 92, 94, 96, 98,100,102,104,106,108,
  7.  110,112,114,116,118,120,122,124,126,128,
  8.  130,132,134,136,138,140,142,144,146,148};

这个是数据是在摄像头高度，角度都确定了之后，在长直道实测出来的数据，赛道每一行的理论赛宽。在后期坡道，横断，环岛的一些阶段，都非常有用。

宽度是用右边界-左边界得到的，单位是像素，需要各位实测得到。

2.边界分析数据

  1.  for (i = MT9V03X_H - 1; i >= 0; i--)//赛道数据初步分析
  2.     {
  3.         if (Left_Lost_Flag[i]  == 1)//单边丢线数
  4.             Left_Lost_Time++;
  5.         if (Right_Lost_Flag[i] == 1)
  6.             Right_Lost_Time++;
  7.         if (Left_Lost_Flag[i] == 1 && Right_Lost_Flag[i] == 1)//双边丢线数
  8.             Both_Lost_Time++;
  9.         if (Boundry_Start_Left ==  0 && Left_Lost_Flag[i]  != 1)//记录第一个非丢线点，边界起始点
  10.             Boundry_Start_Left = i;
  11.         if (Boundry_Start_Right == 0 && Right_Lost_Flag[i] != 1)
  12.             Boundry_Start_Right = i;
  13.         Road_Wide[i]=Right_Line[i]-Left_Line[i];
  14.     }

赛道信息是我们识别元素的关键，主要包括

  1. 左/右边界数组
  2. 左/右丢线数组，左/右丢线数
  3. 双边丢线数
  4. 左/右边界起始点
  5. 赛道截止行
  6. 当前赛道宽度

这些信息都是初步分析得出的数据，在不同的排列组合判断后，还需要根据这些信息进一步去获取角点判断，连续性判断，单调性判断，电磁信号判断等，在进行补线，划线等措施，去判断和处理不同的素。

注：上面并没有计算中线，我因为得到了左右边线，随时都可以用（左+右）/2得到中线。我是在控制方向的时候才去计算中线。

到这里，我们就成果的获取到了一帧图像的大部分数据，下一章将讲简单的控制，车子就可以跑起来了。

希望能够帮助到一些人。

本人菜鸡一只，各位大佬发现问题欢迎留言指出。

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

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

  

闽ICP备14008679号