地形

法一：terrain_generator

GAZEBO构建室外环境地图之创建高度图

GAZEBO构建室外环境地图之加载山地地形

由于我的项目需求是需要甘蔗地的地形模型，对于从卫星地图中获取高程图的办法明显不能达到要求，所以这里我选择采用World Creator 建模，然后导出成高程图：

然后使用opencv调整大小，这里转换了多张不同大小的图像：

#include <opencv2/highgui.hpp>
#include <opencv2/opencv.hpp>
using namespace cv;
using namespace std;
int main(int argc, char **argv)
{
    // read image
    Mat hmap = imread("heightmap.png", IMREAD_GRAYSCALE);
    //Mat hmap = imread("mtsthelens_1025.tif", IMREAD_ANYDEPTH);
    if (hmap.empty()) //如果没有读到图片，则为true
    {
        std::cout << "图片读取错误" << std::endl;
    }
    Mat rmap;
    //把图片改成2^n-1大小的8位图片
    for (int i = 7; i <= 12; i++)
    {
        int map_size = pow(2, i) + 1;
        string addr = "hetmap_png2png" + to_string(map_size) + "_l.png";
        resize(hmap, rmap, Size(map_size, map_size));
        imwrite(addr, rmap);
    }
    /*
    编译：
    g++ test.cpp -o test `pkg-config --cflags --libs opencv4`
    return 0;
}

然后采用资料2中的脚本https://github.com/Sarath18/terrain_generator，生成了.world文件，然后使用gazeo打开，得

查看文件，也找不到材质文件在哪，所以之后另寻他法。

法二：gdal

Gazebo 11分类教程——构建仿真世界（三）

然而，在最后一步出错，并不能复现上面的文章里的效果

GAZEBO_RESOURCE_PATH="$GAZEBO_RESOURCE_PATH:/tmp" gazebo /tmp/volcano.world

也找不到原因：
更多参考文献:
在Gazebo中使用DEM構建起伏地形環境
gazebo仿真记事（二）：gazebo里加载自己的DEM
Digital Elevation Models
gdal将16位的tif转为8位tif
gdalwarp

法三：blender（成功）

参考视频How to create terrain for Gazebo simulation with Blender 2.9了解到使用blender也可以建模（国内我已经转载到了B站）。

视频中的项目地址：Gazebo Terrain Tutorial，按照视频指导，成功建立地形模型并导入gazebo。

一些细节设置的资料：
Blender怎么快速建模一片绿树叶？Blender快速建模一片绿树叶教程
blender2.9怎么快速建模一颗树苗? blender树的建模技巧
最终效果图：

补充：

1.看到有网友说不知道blender如何导入gazebo以及导入后贴图丢失的问题，我做了各视频来演示解决这个问题。

简单点说就是删除model.sdf文件中的下图的内容即可

视频演示：

遗忘越来越快

参考资料:http://www.autolabor.com.cn/book/ROSTutorials/

对于试验，本质就是搭建一个机器人，从控制的角度看，机器人系统可以分为：传感系统、控制系统、驱动系统、执行机构。

执行机构: 执行机构只要满足能在蔗田环境下工作，采用四个直流编码电机带动四个主动轮进行行走，由于执行机构比较简单，不再做单独介绍。

驱动系统: 电池、arduino 以及电机驱动模块；

控制系统: 树莓派；

传感系统: 编码器、单线激光雷达、IMU；

其中，执行机构与驱动系统构成了机器人底盘。

执行机构和驱动系统

执行结构

硬件介绍

底盘是淘宝买的四驱mini小车，由于上位机是树莓派下的ROS，因此为了省事，把重点放在算法的研究上，驱动控制板选择了另一家和ros深度配合的驱动板，该驱动板基于stm32，并且集成了imu惯性传感器，所以把原来买的IMU退了。

经过仔细阅读说明书，发现小车底盘和深度定制的ros驱动板不太兼容，目前有两种方案：

1.驱动板和树莓派ros深度定制，例程丰富，开发手册详细，但是其配的小车不太适合我的的试验环境

2.例程很粗糙，开发手册没有，对应的小车比较适合我们的试验环境

最终我选择了第二种，因为首先试验要保证的是硬件条件能满足试验环境，对于软件环境，我觉得可以多看多学，慢慢研究，并且我也不是完全没基础，对于1中的教程有的显得太过于多余。对于方案2，要考虑的是使用arduino进行四驱小车的pid控制，对于imu信息的接收，可以由arduino承担，也可以直接由树莓派承担，最终的目的就是树莓派中的ros里有imu数据的话题，有编码器的话题，同时考虑将他们如何做成odom信息。

弃用的方案

这里要编写STM32的底层源码
ΜVISION5安装包和安装破解：HTTPS://WWW.MR-WU.CN/KEIL-MDK-UVISION-5-CRACKSTM32控制器程序执行图
初始化和任务对应的代码

接线

驱动系统

对于I2C,其实还有个更新的库，但是这里驱动板的示例程序是基于上面的，为了节约时间，新库以后有时间再研究，新库：

驱动板使用代码学习：

#include <Wire.h>

#define I2C_ADDR        0x34            //12C地址


#define ADC_BAT_ADDR                  0   //电压地址
#define MOTOR_TYPE_ADDR               20 //编码电机类型设置
#define MOTOR_ENCODER_POLARITY_ADDR   21 //设置编码方向极性，
//如果发现电机转速根本不受控制，要么最快速度转动，要么停止。可以将此地址的值重新设置一下
//范围0或1，默认0
#define MOTOR_FIXED_PWM_ADDR      31 //固定PWM控制，属于开环控制,范围（-100~100）
//#define SERVOS_ADDR_CMD 40        
#define MOTOR_FIXED_SPEED_ADDR    51 //固定转速控制，属于闭环控制，
//单位：脉冲数每10毫秒，范围（根据具体的编码电机来，受编码线数，电压大小，负载大小等影响，一般在±50左右）

#define MOTOR_ENCODER_TOTAL_ADDR  60 //4个编码电机各自的总脉冲值
//如果已知电机每转一圈的脉冲数为U，又已知轮子的直径D，那么就可以通过脉冲计数的方式得知每个轮子行进的距离
//比如读到电机1的脉冲总数为P，那么行进的距离为(P/U) * (3.14159*D)
//对于不同的电机可以自行测试每圈的脉冲数U，可以手动旋转10圈读出脉冲数，然后取平均值得出


//电机类型具体值
#define MOTOR_TYPE_WITHOUT_ENCODER        0  //无编码器的电机
#define MOTOR_TYPE_TT                     1  //TT编码电机
#define MOTOR_TYPE_N20                    2  //n20编码电机
#define MOTOR_TYPE_JGB37_520_12V_110RPM   3 //磁环每转是44个脉冲   减速比:90  默认

u8 data[20];
bool WireWriteByte(uint8_t val)
{
    Wire.beginTransmission(I2C_ADDR);//开始一次数据传输，发送一个I2C开始字符0x34
    Wire.write(val);//像从机发送数据
    if( Wire.endTransmission() != 0 ) { //返回值为0才成功，否则失败
        return false;
    }
    return true;
}
//向地址中写入数据 （reg：地址 val：数据内容 len：数据长度）
bool WireWriteDataArray(  uint8_t reg,uint8_t *val,unsigned int len)
{
    unsigned int i;

    Wire.beginTransmission(I2C_ADDR);
    Wire.write(reg);//发送地址数据
    for(i = 0; i < len; i++) {
        Wire.write(val[i]);//发送内容
    }
    if( Wire.endTransmission() != 0 ) {//结果判断
        return false;
    }

    return true;
}
//读取地址中的数据（reg：地址 val：数据内容）
bool WireReadDataByte(uint8_t reg, uint8_t &val)
{
    if (!WireWriteByte(reg)) {//如果WireWriteByte（）非真
        return false;
    }
    
    Wire.requestFrom(I2C_ADDR, 1);//主设备请求从设备I2C_ADDR地址处的一个字节，这个字节可以被主设备用 read()或available()接受
    while (Wire.available()) //接收获取的字节
    {
        val = Wire.read();//Wire.requestFrom()请求从机数据后，可以使用read接收
    }
    
    return true;
}
//读取地址中指定长度的数据（reg：地址 val：数据内容 len：数据长度）
int WireReadDataArray(   uint8_t reg, uint8_t *val, unsigned int len)
{
    unsigned char i = 0;
    
    /* Indicate which register we want to read from */
    if (!WireWriteByte(reg)) {
        return -1;
    }
    
    /* Read block data */
    Wire.requestFrom(I2C_ADDR, len);
    while (Wire.available()) {
        if (i >= len) {
            return -1;
        }
        val[i] = Wire.read();
        i++;
    }
    
    return i;
}


int serial_putc( char c, struct __file * )
{
  Serial.write( c );//Serial.print() 发送的是字符，Serial.write() 发送的字节.
  return c;
}
void printf_begin(void)
{
  fdevopen( &serial_putc, 0 );//将函数serial_putc指向串口
}




uint8_t MotorType = MOTOR_TYPE_TT;  //设定电机类型
uint8_t MotorEncoderPolarity = 1; 
void setup()
{
  Wire.begin();//初始化 I2C，以 Ardunio UNO 为例 I2C 口为：A4(SCL)、A5(CLK)
  Serial.begin(9600);
  printf_begin();
  delay(200);
  WireWriteDataArray(MOTOR_TYPE_ADDR,&MotorType,1);//在电机类型地址中写入电机类型编号
 //向地址中写入数据 （reg：地址 val：数据内容 len：数据长度）
 
  delay(5);
  WireWriteDataArray(MOTOR_ENCODER_POLARITY_ADDR,&MotorEncoderPolarity,1);//向编码方向极性地址中写入MotorEncoderPolarity地址，长度为1

}
/*用数组传递电机速度，正数为设置前进速度，负数为设置后退速度
以 p1、p2 为例：p1=4 个电机以 50 的速度前进 p2=4 个电机以 20 的速度后退*/
int8_t p1[4]={50,50,50,50};
int8_t p2[4]={-50,-50,-50,-50};
int8_t s1[4]={2,2,2,2};
int8_t s2[4]={-2,-2,-2,-2};
//int8_t s1[4]={2,20,10,30};
//int8_t s2[4]={-20,-20,-30,-9};
int32_t EncodeTotal[4]; //用于暂存电机累积转动量的值，正转递增，反转递减
int8_t result[4]={0,0,0,0};
void loop()
{
  u16 v;  //用于暂存电压值
  WireReadDataArray(ADC_BAT_ADDR,data,2);   //读取电压地址中存放的电压
  v = data[0]+ (data[1]<<8); //将电压转换为 mV
  Serial.print("V = ");Serial.print(v);Serial.println("mV     "); //打印电压的值

  WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)EncodeTotal,16);  //读取电机累积转动量
  printf("Encode1 = %ld  Encode2 = %ld  Encode3 = %ld  Encode4 = %ld  \r\n", EncodeTotal[0], EncodeTotal[1], EncodeTotal[2], EncodeTotal[3]);
//打印四个电机的累积转动量
  
/*在电机转速地址中写入电机的转动方向和速度：WireWriteDataArray（转速控制地址，电
机转速数组，电机个数）*/
//  WireWriteDataArray(MOTOR_FIXED_PWM_ADDR,p1,4);//固定pwm控制，开环，属于开环控制,范围（-100~100）
  WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,s1,4);//固定转速控制，闭环，单位：脉冲数每10毫秒，范围（根据具体的编码电机来，受编码线数，电压大小，负载大小等影响，一般在±50左右）
  delay(700);

//  WireWriteDataArray(MOTOR_FIXED_PWM_ADDR,p2,4);
  WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,s2,4);
  delay(700);

  //读取4个电机10ms内的脉冲数据
  for(int i=0;i<10;i++)
  {
  WireReadDataArray(MOTOR_FIXED_SPEED_ADDR,result,4);
  printf("10ms内的脉冲数据为： %ld ， %ld  ， %ld ， %ld  \r\n", result[0], result[1], result[2], result[3]); 
  delay(2000);
  }
}

ros_arduino_bridge

上述代码只有驱动板与arduino交互的驱动，对于arduino与ros的交互，则需要自己编写才行，好在有相关的开源项目，因此在上面进行二次开发即可。我只使用其中的和ros进行交互的部分，对于其中的底盘控制，舵机控制则不使用。

rosserial arduino

ros_arduino-bridge问题较多，换成研究下rosserial arduino试试

1.安装Arduino（树莓派没安装桌面环境，这步可以忽略，编译上传在安装桌面环境的电脑上进行即可）

sudo apt-get install arduino

2.启动arduino并进行相关设置（树莓派没安装桌面环境，这步可以忽略，编译上传在安装桌面环境的电脑上进行即可）

arduino

3.安装软件包rosserial arduino

sudo apt-get install ros-melodic-rosserial-arduino
sudo apt-get install ros-melodic-rosserial

4.编译ros_lib文件，并复制到arduino libraries里（这里是负责编译和上传的电脑的arduino的库里，我的是Windows上的，压缩成zip,然后导入库）

编译：

rosrun rosserial_arduino make_libraries.py [这里写输出目录，中括号要去掉]

在windows上下载下来

然后压缩成zip,在arduino里导入

5.测试，创建helloworld话题

#include <ros.h>
#include <std_msgs/String.h>
ros::NodeHandle nh;
std_msgs::String str_msg;
ros::Publisher chatter("chatter", &str_msg);
char hello[13] = "hello world!";
void setup()
{
  nh.initNode();
  nh.advertise(chatter);
}
void loop()
{
  str_msg.data = hello;
  chatter.publish( &str_msg );
  nh.spinOnce();
  delay(1000);
}

然后插入arduino编译上传后把arduino插到树莓派上

接着在树莓派上分别开终端运行

终端1：

roscore

终端2：（这里硬件端口根据实际情况修改）

rosrun rosserial_python serial_node.py /dev/ttyACM0

终端3：

rostopic echo /chatter

如下图

参考文章

https://www.guyuehome.com/38503

实测电机参数

经过实际测试，电机数据和淘宝上以及卖家给的说明书都不太一致（淘宝的坑？），但是应该可以用。

知道以上参数，可以编写函数来实现测速，即单位位移除以单位时间。

测速函数如下：

long start_time = millis();//一个计算周期的开始时刻，初始值为 millis();
long interval_time = 50;//一个计算周期 50ms
double current_vel[4];
int32_t start_EncodeTotal[4];//构造用于储存开始时的脉冲数的数组
int32_t current_EncodeTotal[4];//构造用于储存当前脉冲数的数组
void get_current_vel()
{
  long right_now = millis();  
  long past_time = right_now - start_time;//计算逝去的时间
   
  if(past_time >= interval_time){//如果逝去时间大于等于一个计算周期
    //1.禁止中断
   // noInterrupts();
    //2.计算转速 转速单位可以是秒，也可以是分钟... 自定义即可
    WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)current_EncodeTotal,16);//获取当前的转动量
    for(int i=0;i<4;i++)
    {
      current_vel[i]=(current_EncodeTotal[i]-start_EncodeTotal[i])*0.3625/past_time;//求当前各个轮子的速度，单位m/s
     
    }
    //3.重置计数器
        for(int i=0;i<4;i++)
    {
      start_EncodeTotal[i]=current_EncodeTotal[i];//求当前各个轮子的速度，单位m/s
    }
    //4.重置开始时间
    start_time = right_now;
    //5.重启中断
   // interrupts();

     Serial.println("四个轮子的速度分别为：");
     Serial.print(current_vel[0]);Serial.print("\t");Serial.print(current_vel[1]);Serial.print("\t");Serial.print(current_vel[2]);Serial.print("\t");Serial.print(current_vel[3]);Serial.println("\t");

  }
}

同时在setup中加入以下代码，获取开始时的转动脉冲数

 WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)start_EncodeTotal,16);//获取开始时的转动量

编码器重置函数和各个电机速度控制函数如下

void rest_encode()//编码器计数清零
{
   EncodeTotal[0]=0,EncodeTotal[1]=0,EncodeTotal[2]=0,EncodeTotal[3]=0;//数组赋值0
  WireWriteDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)EncodeTotal,16);//把驱动板上的编码器计数器归0
  start_EncodeTotal[0]=0;start_EncodeTotal[1]=0;start_EncodeTotal[2]=0;start_EncodeTotal[3]=0;//避免清0后第一次测速数据异常
}
void contrl_vel(int16_t *val)                                             //指定各轮的速度，单位：m/s
{//要把速度转化成脉冲数每10ms,result=val*10/0.3625
  int8_t vel2pulse[4]={0,0,0,0};
  for(int i=0;i<4;i++){
    //vel2pulse[i]=val[i]/100/0.3625;//这里会先把val[i]/100取整型再除以0.3625
    vel2pulse[i]=val[i]/36.25;
  }
    WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,vel2pulse,4);//由于输入的数据只能为整型，控制精度低，后期考虑自己写pid,用pwm
      Serial.println("四个轮子的目标速度（单位mm/s）为：");
     Serial.print(val[0]);Serial.print("\t");Serial.print(val[1]);Serial.print("\t");Serial.print(val[2]);Serial.print("\t");Serial.print(val[3]);Serial.println("\t");
      Serial.println("四个轮子的目标脉冲(单位脉冲/10ms)为：");
     Serial.print(vel2pulse[0]);Serial.print("\t");Serial.print(vel2pulse[1]);Serial.print("\t");Serial.print(vel2pulse[2]);Serial.print("\t");Serial.print(vel2pulse[3]);Serial.println("\t");
     for(int i=0;i<4;i++)
     {
     delay(2000);
     get_current_vel();
     }
}

上面我们把各个轮子单位时间内的脉冲数转化成了小车各个轮子单位时间内能行进的距离，但是要想让机器人运动，我们还是要进行机器人的运动学分析。

机器人运动学分析

参考文献1：https://mp.weixin.qq.com/s/Fzrpn5_3TB6apqG2Ds1v5Q

参考文献2：王雪松. 四驱轮式移动机器人运动控制系统研究与设计[D].上海电机学院,2016.

把机器人的目标速度转换成每个电机的目标速度，这个叫做机器人的运动学分析。

通过机器人各轮的速度求解出机器人沿X、Y、Z轴方向的速度，叫做运动学正解；

通过机器人沿X、Y、Z轴方向的速度求解出机器人各轮的速度，叫做运动学逆解。

卖家资料

细看卖家的最后的四个式子感觉推导的有点尴尬，好在通过阅读资料，我做了简化，控制时保证左侧轮子速度一致，右侧轮子速度也一致，就可以简化为两轮差速控制，如下：

 简化正运动学模型是基于虚拟左右驱动轮的速度来计算几何质心COM的速度，可表示为

        简化逆运动学模型是基于几何质心COM的速度分解出左右驱动轮的速度，可表示为

        若采用公式（9-10）来描述四轮驱动移动机器人(SSMR)，这里有两个点需要进一步讨论：
问题：在正运动学模型（9）中，左右虚拟轮的线速度vl和vr如何得到？
        根据公式（7）可知，两左（或右）侧轮的纵向线速度大小与左（或右）虚拟轮的线速度相同。但两轮的实际转速可能不同。 
        从简化实际运动控制的角度出发，两左（或右）侧轮应该尽可能保持一致。这里做一个假象实验：若机器人的两前轮的速度相同，两后轮的速度相同，但前后轮的速度不同，机器人肯定是以介于前轮速度和后轮速度之间的某一速度直线运动，可想象前轮拖着后轮加快运动，后轮扯着前轮减缓运动。 
        所以无论前后轮的速度如何变化，机器人只会以一个速度运动，由于前后轮速度不相等会引起轮胎与地面在纵向上同时存在滚动和滑动摩擦，这会加速磨损轮胎，且不利于准确运动控制。所以，结论是尽可能保持两左（或右）侧轮速度相同，用数学语言描述就是：、

        式中，[wM1 wM2 wM3 wM4]表示对应轮子的转动角速度，[RM1 RM2 RM3 RM4]表示对应的轮子的半径。
4
问题：虚拟轮间距dLR具体是多少？
        这也是四轮驱动移动机器人(SSMR)简化模型最难的一个参数，是一个随着工况变化的参数，且无法求得解析解。在参考文献[2]中给出的方法，是引入了无量纲参数γ：

       式中，dwb表示机器人的轮间距。 
        问题则转化为如何求γ，该参数与机器人的总负载、轮胎与地面的相对摩擦系数、转弯半径及质心位置都是有关系，是一个非常复杂的参数，所以常用的方法就是做实验，控制不再改动的机器人在特定地面上做差速转向运动，采集到多组实验数据后，拟合估算γ。
        再回过头来看四轮驱动移动机器人(SSMR)运动学模型，基于公式（9-12）可知
正运动学模型为

逆运动学模型为

踩坑

1.断电时一般先断开arduino和上位机（电脑或者树莓派的连线），再断开驱动板和电池的连线，特别是电机失控，要断电急停的时候，否则可能导致驱动板损坏。

2.arduino可以给驱动板供电，驱动板也可以给反向给arduino供电，不知道我是不是在某次操作中，进行了1中的操作，后来发觉驱动板不能给arduino供电了，检查原来是r如下图，重新在后面5v标注的焊点处焊上排针，耶，也可以用。

3.不知道是不是1的操作还把SCL 和SDA的上拉电阻给烧了（新板在路上，保险起见，又买了块），在调试程序中，发现Wire.endTransmission() 函数无响应，并且是间歇性出现，有时重新断开所有电源好了，但是过一会又死在那，然后查了资料（https://arduino.stackexchange.com/questions/5339/wire-endtransmission-hangs），把SCL 和SDA外接一个4.7K的5V上拉电阻，貌似再也没有卡住了

4.自带的示例程序里pwm控制根本没用，轮子只是抖一下，我以为是这板子太垃圾，不支持，于是就用了他的闭环控制，然后我自己又套了层PID，相当于套了2层PID,反应慢。突然我想起了，或许他示例的pwm只是给个脉冲，用循环持续的给脉冲，不就可以了吗，改了下，果真可以。唉，基础不牢，地动山摇。

5.但是使用4中的pwm控制发觉不能低速，最低速度也五秒3米左右，远高于试验要求，然后使用自带的闭环控制，速度可以慢一点，但是还是偏大（整体来说，买的电机减速比偏低），无奈，只能更改ros-arduino-bridge里的pid函数了

6.发觉就算加了上拉电阻，也会卡死，嗐，等新驱动板到了再试

7.为了验证是否是因为基于wire.h库的I2c挂起导致ros_arduino_bridge无法连接，编译上传不含有i2c的ros_arduino_bridge项目到arduino试试。经验证，果真是，嗐，卖家配的示例真坑

8.使用github另外一位大佬改编的IC2库（https://github.com/rambo/I2C），成功移植之前的代码，然后成功连接，现在就是改ros_arduino_python里的关于pid的代码，把他屏蔽掉就行

9.实测在连接书梅派串口后，i2c总线会卡死，导致连接不上，就算使用了新的I2C.h库，超时可以跳出，可以连接上，但三仍然功能不正常，暂时找不到解决方案，时间关系，以后再研究。

10.问题解决，arduino的供电来自树莓派，驱动板的供电来自电源，两个之前的vcc不用连接，连接gnd即可，在arduino程序启动的时候可以先不建立I2c通信，后面再初始话硬件然后通信

控制系统

使用ros控制电机转动从而控制小车运动，之前尝试有太多bug,并且也不是我试验的重点，花大量时间不值得，所以就修改为使用蓝牙遥控器控制，和arduino上的驱动系统相集成，因此arduino上一共集成了以下代码：I2C通信代码 红外控制电机代码 ros_arduino_bridge代码

首先，检测遥控器的按键编码：（灯没必要接，接好红外传感器就行）

#include <IRremote.h>
int RECV_PIN = 11;
int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
long on1  = 0x00FFA25D;//1
long off1 = 0x00FFE01F;
long on2 = 0x00FF629D;//2
long off2 = 0x00FFA857;
long on3 = 0x00FFE21D;//3
long off3 = 0x00FF906F;
long on4 = 0x00FF22DD;
long off4 = 0x00FF6897;
long on5 = 0x00FF02FD;//5
long off5 = 0x00FF9867;
long on6 = 0x00FFC23D;
long off6 = 0x00FFB04F;
IRrecv irrecv(RECV_PIN);
decode_results results;
// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
//  decode_results *results = (decode_results *)v
void dump(decode_results *results) {
  int count = results->rawlen;
  if (results->decode_type == UNKNOWN)
  {
    Serial.println("Could not decode message");
  }
  else
  {
    if (results->decode_type == NEC)
    {
      Serial.print("Decoded NEC: ");
    }
    else if (results->decode_type == SONY)
    {
      Serial.print("Decoded SONY: ");
    }
    else if (results->decode_type == RC5)
    {
      Serial.print("Decoded RC5: ");
    }
    else if (results->decode_type == RC6)
    {
      Serial.print("Decoded RC6: ");
    }
    Serial.print(results->value, HEX);
    Serial.print(" (");
    Serial.print(results->bits, DEC);
    Serial.println(" bits)");
  }
  Serial.print("Raw (");
  Serial.print(count, DEC);
  Serial.print("): ");

  for (int i = 0; i < count; i++)
  {
    if ((i % 2) == 1) {
      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    }
    else
    {
      Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(" ");
  }
  Serial.println("");
}

void setup()
{
  pinMode(RECV_PIN, INPUT);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  pinMode(13, OUTPUT);
  Serial.begin(9600);

  irrecv.enableIRIn(); // Start the receiver
}

int on = 0;
unsigned long last = millis();

void loop()
{
  if (irrecv.decode(&results))
  {
    // If it's been at least 1/4 second since the last
    // IR received, toggle the relay
    if (millis() - last > 250)
    {
      on = !on;
      //       digitalWrite(8, on ? HIGH : LOW);
      digitalWrite(13, on ? HIGH : LOW);
      dump(&results);
    }
    if (results.value == on1 )
    {
      Serial.println("1号键");
      digitalWrite(LED1, HIGH);
    }
    if (results.value == off1 )
    {
      digitalWrite(LED1, LOW); Serial.println("2号键");
    }
    if (results.value == on2 )
    {
      digitalWrite(LED2, HIGH); Serial.println("3号键");
    }
    if (results.value == off2 )
    {
      digitalWrite(LED2, LOW); Serial.println("4号键");
    }
    if (results.value == on3 )
    {
      digitalWrite(LED3, HIGH); Serial.println("5号键");
    }
    if (results.value == off3 )
      digitalWrite(LED3, LOW);
    if (results.value == on4 )
      digitalWrite(LED4, HIGH);
    if (results.value == off4 )
      digitalWrite(LED4, LOW);
    if (results.value == on5 )
      digitalWrite(LED5, HIGH);
    if (results.value == off5 )
      digitalWrite(LED5, LOW);
    if (results.value == on6 )
      digitalWrite(LED6, HIGH);
    if (results.value == off6 )
      digitalWrite(LED6, LOW);
    last = millis();
    irrecv.resume(); // Receive the next value
  }
}

然后编写控制逻辑代码，最后集成的时候在相关地方加入控制函数即可

#include <IRremote.h>
int RECV_PIN = 11;//11号引脚为数据引脚
long accelerate = 0x00FF629D;//2号数字键,前进/加速
long decelerate = 0x00FF02FD;//5号键，后退/减速
long  left=  0x00FFA25D;//1号数字键，左转
long right=  0x00FFE21D;//3号数字键，右转
long carstop =  0x00FF38C7;//停止，OK键
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup() {
pinMode(RECV_PIN, INPUT);
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
int on = 0;
unsigned long last = millis();
void loop() {
   if (irrecv.decode(&results))
  {
    // If it's been at least 1/4 second since the last
    // IR received, toggle the relay
    if (millis() - last > 250)
    {
      on = !on;
      digitalWrite(13, on ? HIGH : LOW);
      //dump(&results);
    }
    if (results.value == accelerate )
    {
      Serial.println("前进");
     
    }
    if (results.value == decelerate )
    {
      Serial.println("后退");
    }
    if (results.value == left )
    {
     Serial.println("左转");
    }
    if (results.value == right )
    {
      Serial.println("右转");
    }
    if (results.value == carstop )
    {
      Serial.println("停止");
    }
    last = millis();
    irrecv.resume(); // Receive the next value
  }
}

传感系统

查看局域网其他计算机ip

windows:
以管理员身份运行cmd输入net view后回车，即可查看到自己的计算机所在的局域网内的其他计算机的计算机名
ping 计算机名 ，可以查到其ip
或者使用局域网查看工具：

ubuntu:
使用sudo apt-get install arp-scan 安装(确保网络链接正常)

利用ifconfig 或ip addr 查看本机的ip地址,一般有线在interface en0/eth0, 无线在wlan0上.
ifconfig
然后使用arp-scan -I wlo1 –localnet 或 sudo arp-scan -I wlo1 –localnet 就可以查看同一局域网的其他设备
sudo arp-scan -I wlp3s0 –localnet
wlp3s0换成自己的网口名

sudo apt install arp-scan -y

sudo arp-scan -I wlp3s0 --localnet

ubuntu镜像下载：http://cdimage.ubuntu.com/releases/

由于我用到的ros arduino bridge 不支持我的ros-noetic,所以树莓派上必须安装ros-melodic,笔记本上可以用原来的不变。而ros-melodic是在ubuntu18.04环境下，故树莓派的安装版本为：ubuntu18.04+rosmelodic,但是官方的软件刷ubuntu18.04设置得wifi不生效，于是https://blog.csdn.net/qq_30613365/article/details/120739069

树莓派上部署ROS：

一行代码搭建机器人开发环境(ROS/ROS2/ROSDEP)

wget http://fishros.com/install -O fishros && . fishros

使用树莓派官方的工具刷入ubuntu20.04，刷入之前设置好用户名、密码、wifi等信息（这里我设置成收手机的，因为以后试验也是用手机共享热点当成无线路由器），同时记得打开ssh，为了方便远程连接(这里主要是不想电脑也连接手机wifi)，我们进入系统后首先安装zerotier，然后再使用上面小鱼的一键安装命令安装无桌面版ros，安装结束后添加到环境变量：

echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
source ~/.bashrc

然后用小鱼工具箱安装rosdepc

rosdepc init
rosdepc update

最后roscore启动，没错误，ros环境部署成功。

树莓派配置网络出现问题之解决办法

踩坑

创建工作空间并初始化

mkdir -p field_trial/src

cd field_trial/

catkin_make

如果提示没安装catkin，安装又发现和ros的依赖冲突，这里可以先卸载ros然后先安装catkin，再安装ros

1.catkin_make报错：IOError: [Errno 13] Permission denied:

https://answers.ros.org/question/246820/ros_arduino_bridge-reconnection-error/

https://blog.csdn.net/gongdiwudu/article/details/123983828

原因是创建工作空间时用了sudo或者在root下，解决方案：

sudo chown $USER: -R /home/pi/ros_catkin_ws

2.diagnostic_updater“,CMake did not find diagnostic_updater.

缺少相应的依赖包，可以：

sudo apt-cache search diagnostics updater #在apt源里寻找同样名字的包

根据返回安装合适的依赖包

sudo apt install ros-humble-diagnostic-updater

激光雷达相关

连接上激光雷达，并认当前的 USB 转串口终端并修改权限，

USB查看命令:

ll /dev/ttyUSB*

如果找不到，可能是数据线问题，换一根数据线即可。

使用

ls -l /dev/ttyUSB0

发现，当前用户没有使用它的权限，因此要添加权限

sudo usermod -a -G dialout 你的用户名

之后要重启才能生效

由于本次试验有多个外接设备，为了不造成串口混乱，可以绑定串口设备

雷达驱动包安装：

进入src工作空间，然后下载驱动包

git clone https://github.com/slamtec/rplidar_ros

返回工作空间，并catkin_make编译，并source ./devel/setup.bash，把功能包里的launch文件的设备端口改成之前映射好的端口。

测试

启动驱动包里的例程，如果不报错且能正确获取到当前雷达的信息，则没问题，我这里暂时没有做分布式，树莓派上安装的是无桌面版本，所以就不能通过rviz查看。

roslaunch rplidar_ros rplidar.launch

通过 rostopic list和rostopic echo /scan也能看到相关信息输出

IMU相关

参考资料：https://blog.csdn.net/ganjb1/article/details/118153554

参考项目：https://github.com/COONEO/Arduino_Jetson_nano_ROS_Car/tree/melodic/Jetson_nano_ROS_code/catkin_ws/src/imu_901

如何将 IMU （惯性测量单元） 传感器与 Arduino 对接

开源！手把手教你搭建Arduino+英伟达Jetson的ROS小车（中）

https://blog.csdn.net/zhuoyueljl/article/details/75453808

1.在windows电脑上使用商家提供的上位机软件设置IMU参数

2.然后把设备插到ubuntu设备的usb口上

安装串口功能包：

sudo apt-get install ros-melodic-serial

然后创建imu信息读取解析的相关功能包（参考教程：https://blog.csdn.net/qqliuzhitong/article/details/114384297）

catkin_create_pkg serial_demo roscpp serial

能再屏幕上打印后根据芯片的开发手册对串口数据进行解码，最后编写数据发布代码发布/imu

相关代码如下：

编码器相关

我的是arduino接收编码器的信息，然后arduino再通过ros_arduino_bridge和编码器交互，在ros端，我主要使用的是ros_arduino_python 下的arduino_drive.py.

查看权限

ls -l /dev/ttyACM0

授权（前面雷达部分已经弄过就可以不弄了）

sudo usermod -a -G dialout your_user_name

ros_arduino_bridge是依赖于python-serial功能包的

sudo apt-get install python-serial

在ros_arduino_msg中添加自定义编码器消息

Header header
int16 voltage
int32[4] enc

然后按照ros自定义消息的步骤进行配置和编译，最后在arduino_drive.py中进行解析和发布话题

odom里程计

odom里程计数据由编码器和imu数据融合而成，https://blog.csdn.net/baimei4833953/article/details/80768762

imu tool:
http://wiki.ros.org/imu_complementary_filter?distro=noetic

论文：https://www.mdpi.com/1424-8220/15/8/19302

两种融合的方法
（1） 一种简单的方法
从imu得到的数据为一个相对角度(主要使用yaw，roll和pitch 后面不会使用到)，使用该角度来替代由编码器计算得到的角度。
这个方法较为简单，出现打滑时候因yaw不会受到影响，即使你抬起机器人转动一定的角度，得到的里程也能正确反映出来

（2）扩展的卡尔曼滤波
官方提供了个扩展的卡尔曼滤波的包robot_pose_ekf，robot_pose_ekf开启扩展卡尔曼滤波器生成机器人姿态，支持

odom（编码器）
imu_data（IMU）
vo（视觉里程计）
还可以支持GPS
引用官方图片

chatGPT真是个神器：

集成

TF坐标变换

预备知识：https://www.jianshu.com/p/cb99188fec49

在launch文件中增加以下节点的代码：

<node pkg="tf2_ros" type="static_transform_publisher" name="imu_transform_publisher" args="0 0 0 0 0 0 base_link imu_link 100" />

<node pkg="tf2_ros" type="static_transform_publisher" name="imu_static_transform_publisher" args="x y z yaw pitch roll base_link imu_link 100" />

ROS std_msgs/Header 数据含义

https://blog.csdn.net/qq_18676517/article/details/109270525

创建功能包

catkin_create_pkg integration roscpp rospy std_msgs ros_arduino_python usb_cam rplidar_ros

功能包下创建launch文件夹，launch文件夹中新建run.launch文件,内容如下：

<!-- 机器人启动文件：
        1.启动底盘
        2.启动激光雷达
        3.IMU
        4.启动编码器
        5.启动odom
        6.录制数据
 -->
<launch>
        <!-- <include file="$(find ros_arduino_python)/launch/arduino.launch" /> -->
        <!-- <include file="$(find usb_cam)/launch/usb_cam-test.launch" /> -->
         <!-- 2.启动激光雷达 -->
        <include file="$(find rplidar_ros)/launch/rplidar.launch" />
        <!-- 6.录制数据 -->
        <!-- <node pkg="rosbag" type="record" name="record" args="/imu /odom /scan /tf /tf_static  -o /home/daoker/vscode_ws/src/sugarcane_car/bag/onece.bag"/> -->
        <node pkg="rosbag" type="record" name="record" args="/scan   -o /home/daoker/field_trial/src/integration/bag/onece.bag"/>
         <node pkg="tf2_ros" type="static_transform_publisher" name="static_transform_publisher" args="0 0 0 -1.57 0 -1.57 /front_bumper_link /front_bumper_link_depth" />
    <node pkg="tf" type="static_transform_publisher" name="odom_to_world" args="0.0 0.0 0.0 0 0 0.0 /odom /world 1000"/>
    <node pkg="rosbag" type="record" name="record" args="/imu /odom /scan /tf /tf_static  -o /home/daoker/vscode_ws/src/sugarcane_car/bag/onece.bag"/>

</launch>

//Jacobi.cpp
#include "Jacobi.h"
#include <iostream>
#include <vector>
#include <stdlib.h>
using namespace std;
using std::vector;
vector<double> matrix_A;
vector<double> vector_b;

Jacobi::Jacobi()
{
	cout << "输入方阵维数：";
	cin >> order;
	std::cout << order << "阶矩阵构造成功" << endl; 
}



void Jacobi::input_matrix_A()
{	//由于数组在编译阶段就已经分配内存，维度必须是常量，故此处用向量来存储矩阵
	//初始化为order*order个int元素，没个元素都被初始化为0
	
	double elemt = 0;
	for (int i = 0; i <= order * order - 1; i++)
	{
		cout << "输入第" << i + 1 << "个元素" << endl;
		cin >> elemt;
		matrix_A.push_back(elemt);
	}
	pointer_A = &matrix_A[0];
	cout << "输入的矩阵为" << endl;
	output_matrix(pointer_A);
	
}

void Jacobi::input_vector_b()
{
	double element;
	for (int i = 0; i < order; i++)
	{
		cout << "请输入第" << i + 1 << "个b元素" << endl;
		cin >> element;
		vector_b.push_back(element);//构造成Ax-b=0
	}
	pointer_b = &vector_b[0];
	cout << "输入的列向量为" << endl;
	output_vector(pointer_b);
	
}
void Jacobi::structure_iterator()
{
	
	
	
	for (int i = 0; i <= order - 1; i++)
	{
		int denominator = pointer_A[i * order + i];
		pointer_b[i] = (pointer_b[i]) / denominator;
		for (int j = 0; j <= order - 1; j++)
		{
			pointer_A[i * order + j] = -(pointer_A[i * order + j]) / denominator;
		}
		pointer_A[i * order + i] = 0;
		
	}
	cout << "绝对误差限";
	double e;
	cin >> e;
	vector<double> vector_xk(order, 0);
	int n = 0,k=0;//n为满足绝对误差的解的个数,k为迭代次数
	do
	{
		n = 0;
		vector<double> vector_xk1(order, 0);//每次都初始化k+1
		
		for (int i = 0; i < order; i++)
		{
			for (int j = 0; j < order; j++)
			{
				vector_xk1[i] += (vector_xk[j] * pointer_A[i * order + j]);
			}
			vector_xk1[i] += pointer_b[i];
		}
		
		for (int i = 0; i < order; i++)
		{
			
			if (abs(vector_xk[i]-vector_xk1[i]) < e) 
			{
				n++;
			}

		}
		vector_xk = vector_xk1;
		k++;
		cout << "k=" << k << endl;
		output_vector(&vector_xk[0]);
	} while (n<order);

}
void Jacobi::output_matrix(double* p)
{
	double* pointer = p;
	for (int i = 0; i <= order - 1; i++)
	{
		for (int j = 0; j <= order - 1; j++)
		{
			cout << pointer[i * order + j] << "\t";
		}
		cout << endl;
	}

}

void Jacobi::output_vector(double* q)
{
	double* pointer = q;
	for (int i = 0; i < order; i++)
	{
		cout << pointer[i] << "\t";
	}
	cout << endl;
}```

```cpp
//Jacobi.h
#ifndef _JACOBI_H_
#define _JACOBI_H_

class Jacobi
{
public:
	void input_matrix_A(); //输入系数矩阵A
	void input_vector_b();//输入AX=b中的向量b
	void structure_iterator();//构造迭代公式
	void output_matrix(double* p);//输出矩阵
	void output_vector(double* q);//输出向量
	

	Jacobi();
private:
	
	double*  pointer_A = 0;//指向系数矩阵的指针
	double* pointer_b = 0;//指向b的指针
	int order = 0; //矩阵阶数
};

#endif

/*powell.cpp*/
#include "stdafx.h"
#include <stdio.h>
#include <math.h>
#include "Powell.h"
#include <iostream>
#define m 10              /*数组长度m  >=  维数n    */


float powell::powell_f(float x[])
{
	float result;
	//result = (x[0] - 2)*(x[0] - 2) + (x[1] - 3)*(x[1] - 3) + (x[2] - 4)*(x[2] - 4);
	result = x[0] * x[0] + 2 * x[1] * x[1] - 2 * x[0] * x[1] - 4 * x[0];
	return result;
}

/*多维进退法子程序*/
void powell::mjtf(int n, float x0[], float h, float s[], float a[], float b[])
{
	int i;
	float x1[m], x2[m], x3[m], powell_f1, powell_f2, powell_f3;
	for (i = 0; i<n; i++)         /*计算初始两试点*/
	{
		x1[i] = x0[i];
		x2[i] = x0[i] + h*s[i];
	}
	powell_f1 = powell_f(x1);
	powell_f2 = powell_f(x2);
	if (powell_f2 >= powell_f1)               /*判断搜索方向*/
	{                       /*搜索方向为反向，转身*/
		h = (-1)*h;
		for (i = 0; i<n; i++)
			x3[i] = x1[i];
		powell_f3 = powell_f1;
		for (i = 0; i<n; i++)
			x1[i] = x2[i];
		powell_f1 = powell_f2;
		for (i = 0; i<n; i++)
			x2[i] = x3[i];
		powell_f2 = powell_f3;
	}                       /*搜索方向为正向*/

	for (i = 0; i<n; i++)         /*计算第三试点*/
		x3[i] = x2[i] + h*s[i];
	powell_f3 = powell_f(x3);
	while (powell_f3<powell_f2)             /*判断是否未完成搜索*/
	{                       /*未完成，继续搜索*/
		h = 2 * h;
		for (i = 0; i<n; i++)
			x1[i] = x2[i];
		powell_f1 = powell_f2;
		for (i = 0; i<n; i++)
			x2[i] = x3[i];
		powell_f2 = powell_f3;
		for (i = 0; i<n; i++)
			x3[i] = x2[i] + h*s[i];
		powell_f3 = powell_f(x3);
	}                       /*已完成*/
	for (i = 0; i<n; i++)         /*输出初始搜索区间*/
	{
		if (x1[i]<x3[i])
		{
			a[i] = x1[i];
			b[i] = x3[i];
		}
		else
		{
			a[i] = x3[i];
			b[i] = x1[i];
		}
	}
}

/*多维黄金分割法子程序*/
void powell::mhjfgf(int n, float a[], float b[], float flag, float x[])
{
	int i;
	float x1[m], x2[m], powell_f1, powell_f2, sum;
	for (i = 0; i<n; i++)              /*计算初始两试点*/
		x1[i] = b[i] - (float)0.618*(b[i] - a[i]);
	powell_f1 = powell_f(x1);
	for (i = 0; i<n; i++)
		x2[i] = a[i] + (float)0.618*(b[i] - a[i]);
	powell_f2 = powell_f(x2);
	do
	{
		if (powell_f1 <= powell_f2)                  /*判断消去区间*/
		{                          /*消去右*/
			for (i = 0; i<n; i++)
				b[i] = x2[i];
			for (i = 0; i<n; i++)
				x2[i] = x1[i];
			powell_f2 = powell_f1;
			for (i = 0; i<n; i++)
				x1[i] = b[i] - (float)0.618*(b[i] - a[i]);
			powell_f1 = powell_f(x1);
		}
		else
		{                          /*消去左*/
			for (i = 0; i<n; i++)
				a[i] = x1[i];
			for (i = 0; i<n; i++)
				x1[i] = x2[i];
			powell_f1 = powell_f2;
			for (i = 0; i<n; i++)
				x2[i] = a[i] + (float)0.618*(b[i] - a[i]);
			powell_f2 = powell_f(x2);
		}
		sum = 0;
		for (i = 0; i<n; i++)
			sum += (b[i] - a[i])*(b[i] - a[i]);
	} while (sqrt(sum)>flag*0.1);
	for (i = 0; i<n; i++)
		x[i] = (float)0.5*(b[i] + a[i]);
}

/*鲍威尔法子程序*/
void powell::mbwef(int n, float x0[], float h, float flag, float a[], float b[], float x[])
{
	int i, j, k, r;
	float x1[m], x11[m], x2[m], powell_f0, powell_f1, powell_f2, fn[m], s[m][m], sum;
	for (i = 0; i<n; i++)//构造一个单位对角矩阵s
		for (k = 0; k<n; k++)
			if (i == k)
				s[i][k] = 1;
			else
				s[i][k] = 0;
	k = 0;
	while (1)
	{
		for (i = 0; i<n; i++)
		{
			x1[i] = x0[i];
			x11[i] = x1[i];
		}
		for (i = 0; i<n; i++)
		{
			mjtf(n, x1, h, s[i], a, b);
			mhjfgf(n, a, b, flag, x1);
			fn[i] = powell_f(x11) - powell_f(x1);
		}
		for (i = 0; i<n; i++)
			x2[i] = 2 * x1[i] - x0[i];
		for (i = 1; i<n; i++)
			if (fn[0]<fn[i])
			{
				fn[0] = fn[i];
				r = i;
			}
			else
				r = 0;
		powell_f0 = powell_f(x0);
		powell_f1 = powell_f(x1);
		powell_f2 = powell_f(x2);
		if (powell_f2 >= powell_f0 || (powell_f0 - 2 * powell_f1 + powell_f2)*(powell_f0 - powell_f1 - fn[0])*(powell_f0 - powell_f1 - fn[0]) >= 0.5*fn[0] * (powell_f0 - powell_f2)*(powell_f0 - powell_f2))
		{
			sum = 0;
			for (i = 0; i<n; i++)
				sum += (x1[i] - x0[i])*(x1[i] - x0[i]);
			if (powell_f1 <= powell_f2)
				for (i = 0; i<n; i++)
					x0[i] = x1[i];
			else
				for (i = 0; i<n; i++)
					x0[i] = x2[i];
		}
		else
		{
			for (i = r; i<n - 1; i++)
				for (j = 0; j<n; j++)
					s[i][j] = s[i + 1][j];
			for (i = 0; i<n; i++)
				s[n - 1][i] = x1[i] - x0[i];
			mjtf(n, x1, h, s[n - 1], a, b);
			mhjfgf(n, a, b, flag, x1);
			sum = 0;
			for (i = 0; i<n; i++)
				sum += (x1[i] - x0[i])*(x1[i] - x0[i]);
			for (i = 0; i<n; i++)
				x0[i] = x1[i];
		}
		if (sqrt(sum) <= flag)
			break;
		else
			k += 1;
	}
	for (i = 0; i<n; i++)
		x[i] = x1[i];
}

/*鲍威尔法主程序*/

int main(void)
{
	int i, n = 2;
	float h, flag, x0[m], a[m], b[m], x[m];
	printf("\n<鲍威尔法>\n");
	/*printf("请输入维数:\n");
	scanf_s("%d", &n);*/
	printf("请输入初始点:");
	for (i = 0; i<n; i++)
	{
		printf("\nx0[%d]=", i);
		scanf_s("%f", &x0[i]);
	}
	printf("\n请输入初始步长:\n");
	scanf_s("%f", &h);
	printf("\n请输入精度:\n");
	scanf_s("%f", &flag);
	powell one;
	one.mbwef(n, x0, h, flag, a, b, x);
	printf("\n极小点坐标为:\n");
	for (i = 0; i<n; i++)
		printf("x[%d]=%f\n", i, x[i]);
	printf("\n极小值为:\n%f\n", one.powell_f(x));
	while (1)
	{
		;
	}

}

#ifndef _powell_h_
#define _powell_h_

class powell
{
public:
	float powell_f(float x[]);
	void mjtf(int n, float x0[], float h, float s[], float a[], float b[]);
	void mhjfgf(int n, float a[], float b[], float flag, float x[]);
	void mbwef(int n, float x0[], float h, float flag, float a[], float b[], float x[]);
private:

};

#endif // !
#pragma once

#ifndef _Quadratic_interpolation_H
#define _Quadratic_interpolation_H

#include <iostream> 
#include <vector>
#include <math.h>
#define f1 function_value[0]
#define f2 function_value[1]
#define f3 function_value[2]
#define X1 X_value[0]
#define X2 X_value[1]
#define X3 X_value[2]
#define f(x) this->solve_f_value(x-1)
//#define dataNum 100
class solve_problem
{
public:
	  solve_problem(void);
	  void quad_inter();
	  void Interval_elimination();
	  double solve_f_value(int Serial_number);
	  void span_left();
	  void span_right();
	  int draw_picture();
	  ~solve_problem(void);
	  
private:
	double Coefficient_matrix[4];
	double H=0;
	double function_value[3] = {0,0,0};
	double X_value[3] = { 0,0,0 };
	int cnt=0;
	double left_doit=0, right_doit=0;
	double Precision_e = 0;
	double xp = 0;
	double f4 = 0;
};

#endif

/*Quadratic_interpolation.cpp*/
#include <iostream>
#include "Quadratic_interpolation.h"
#include "stdafx.h"
#include "draw_picture.h"
#define dataNum 100
using namespace std;
int main()
{
	int select = 0;
	while (!select)
	{
		solve_problem* one = new solve_problem();
		one->Interval_elimination();
		one->quad_inter();
		one->draw_picture();
		cout << "输入1开始新的计算,输入其他则退出程序" << endl;
		cin >> select;
		if (1 == select)
		{
			delete one;
			select = 0;
		}
		else
		{
			return 0;
		}
	}

}

solve_problem::solve_problem(void)//构造函数
{
	cout << "请输入方程的系数\t" << endl;
	for (int i = 0; i<4; ++i)
	{
		cin >> Coefficient_matrix[i];
	}
	cout << "输入的方程为：f(x)=" << showpos << Coefficient_matrix[0] << "x^3" << Coefficient_matrix[1] << "x^2" << Coefficient_matrix[2] << "x" << Coefficient_matrix[3] << endl;
}//
solve_problem::~solve_problem(void)
{
	cout << "计算结束" << endl;
}
void solve_problem::Interval_elimination()//区间消去函数
{
	cout << "******************************求解单封区间***************************" << endl;
	cout << "输入初始点X1和步长H" << endl;
	cin >> X1 >> H;
	cout << "初始点X1=" << noshowpos << X1 << "\t" << "步长H=" << H << endl;
	cnt = sizeof(Coefficient_matrix) / sizeof(Coefficient_matrix[0]);//获取数组元素个数
	f1 = f(1);	X2 = X1 + H;	f2 = f(2);
	if (f1 <= f2)
	{
		H = -H;	X3 = X1;f3 = f1;X1 = X2;f1 = f2;X2 = X3;f2 = f3;
	}
	H *= 2;	X3 = X2 + H;	f3 = f(3);

	while (f3 <= f2)
	{
		X1 = X2;f1 = f2;X2 = X3;f2 = f3;H *= 2;X3 = X2 + H;	f3 = f(3);
	}
	if (H > 0)
	{
		left_doit = X1;		right_doit = X3;
	}
	else
	{
		left_doit = X3;		right_doit = X1;
	}
	cout << "单封区间为[" << this->left_doit << "," << this->right_doit << "]" << endl;

}//区间消去函数

void solve_problem::quad_inter()//二次插值函数
{
	cout << "*****************使用二次插值法求极值点************************" << endl;
	cout << "输入收敛精度e" << endl;
	cin >> Precision_e;
	cout << "方程f(x)=" << showpos << Coefficient_matrix[0]
		<< "x^3" << Coefficient_matrix[1]<< "x^2" << Coefficient_matrix[2] 
		<< "x" << Coefficient_matrix[3] << endl;
	cout << "的单封区间为[" << this->left_doit << "," << this->right_doit << "]" << endl;
	cout << "收敛精度为e=" << this->Precision_e << endl;
	cout << "*****************************求解开始************************" << endl;
	X1 = left_doit;
	X3 = right_doit;
	X2 = 0.5*(X1 + X3);
	f1 = f(1);
	f2 = f(2);
	f3 = f(3);
	span_left();
}

double solve_problem::solve_f_value(int Serial_number)
{
	double value = 0;

	for (int i = 0; i < 4; i++)
	{
		value += this->Coefficient_matrix[i] * (pow(X_value[Serial_number], cnt - i - 1));
	}
	return(value);
}

void solve_problem::span_left()
{
	double c1 = (f3 - f1) / (X3 - X1);
	double c2 = ((f2 - f1) / (X2 - X1) - c1) / (X2 - X3);
	if (c2 != 0)
	{
		xp = 0.5 * (X1 + X3 - c1 / c2);		if ((xp - X1) * (X3 - xp) > 0)
		{
			f4 = 0;
			for (int i = 0; i < 4; i++)
			{
				f4 += this->Coefficient_matrix[i] * (pow(xp, cnt - i - 1));
			}
			if (abs(xp - X2) < Precision_e)
			{
				if (f4 < f2)
				{
					cout << "极限值在x=" << xp << "处取得" << endl;
					cout << "f(" << xp << ")=" << f4 << endl;
				}
				else
				{
					cout << "极限值在x=" << X2 << "处取得" << endl;
					cout << "f(" << X2 << ")=" << f2 << endl;
				}
			}
			else
			{
				this->span_right(); //右边函数块
			}
		}
		else
		{
			cout << "极限值在x=" << X2 << "处取得" << endl;
			cout << "f(" << X2 << ")=" << f2 << endl;
		}
	}
	else if (c2 == 0)
	{
		cout << "极限值在x=" << X2 << "处取得" << endl;
		cout << "f(" << X2 << ")=" << f2 << endl;
	}
}

void solve_problem::span_right()
{
	if (xp > X2)
	{
		if (f2 > f4)
		{
			X1 = X2;
			f1 = f2;
			X2 = xp;
			f2 = f4;
		}
		else
		{
			X3 = xp;
			f3 = f4;
		}
	}
	else if (f2>f4)
	{
		X3 = X2;
		f3 = f2;
		X2 = xp;
		f2 = f4;
	}
	else
	{
		X1 = xp;
		f1 = f4;
	}
	this->span_left();
}
int solve_problem::draw_picture()
{
	
	Engine* eg = NULL;
	if (!(eg = engOpen(NULL)))
	{
		printf("Open matlab enging fail!");
		return 1;
	}

	int ret = 0;

	double xtemp[dataNum] = { 0 };
	double ytemp[dataNum] = { 0 };
	double distance = this->right_doit - this->left_doit;
	distance = 2*distance;
	double value;
	for (int i = 0; i < dataNum; i++)
	{
		xtemp[i] =(X1-0.5*distance)+ i * distance / dataNum;
	    value = 0;

		for (int j = 0; j < 4; j++)
		{ 
			
			value += this->Coefficient_matrix[j] * pow(xtemp[i], cnt - j - 1);
			
		}
		ytemp[i] = value;

	}
	mat_plot(eg, xtemp, ytemp, dataNum, "-r", 1, 5);
	for (int i = 0; i < dataNum; i++)
	{
		xtemp[i] = (X1 - 0.5*distance) + i * distance / dataNum;
		value = 0;

		for (int j = 0; j < 4; j++)
		{

			value += this->Coefficient_matrix[j] * pow(xtemp[i], cnt - j );

		}
		ytemp[i] = value;

	}
	mat_plot(eg, xtemp, ytemp, dataNum, "-r", 1, 5);

	getchar();
	if (eg)
		engClose(eg);
	return 0;
}

#ifndef _draw_picture_h_
#define _draw_picture_h_

#include "stdafx.h"
#include "draw_picture.h"
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<engine.h>

extern int mat_plot(Engine *eg, double *x, double *y, int N, char *LineStyle, double LineWidth, double MarkerSize);



#endif // !_draw_picture_h_
#pragma once

// draw_picture.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "draw_picture.h"
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<engine.h>

extern int mat_plot(Engine *eg, double *x, double *y, int N, char *LineStyle, double LineWidth, double MarkerSize);

//忽略4096错误
#pragma warning(disable:4996)

int mat_plot(Engine *eg, double *x, double *y, int N, char *LineStyle, double LineWidth, double MarkerSize)
{
	int ret = 0;
	mxArray *X = mxCreateDoubleMatrix(1, N, mxREAL);
	mxArray *Y = mxCreateDoubleMatrix(1, N, mxREAL);
	mxArray *MS = mxCreateDoubleScalar(MarkerSize);
	memcpy(mxGetPr(X), x, N * sizeof(double));
	memcpy(mxGetPr(Y), y, N * sizeof(double));

	if ((ret = engPutVariable(eg, "X", X)) != 0)
		printf("engPutVariable error：%d\n", ret);
	if ((ret = engPutVariable(eg, "Y", Y)) != 0)
		printf("engPutVariable error：%d\n", ret);

	//gennerate the plot command
	char plotCommand[256] = "fig=plot(X,Y,'";
	//set line style and marker
	if (strlen(LineStyle) > 0)
		strncat(plotCommand, LineStyle, strlen(LineStyle));
	else
	{
		strncat(plotCommand, "-", strlen("-"));
	}
	strncat(plotCommand, "',", strlen(LineStyle));

	char temp[20] = "";
	//set line width
	if (LineWidth < 1.0)
		LineWidth = 1.0;
	strncat(plotCommand, "'LineWidth',", strlen("'LineWidth',"));
	memset(temp, 0, sizeof(temp));
	sprintf(temp, "%f,", LineWidth);
	strncat(plotCommand, temp, strlen(temp));

	//set marker size
	strncat(plotCommand, "'MarkerSize',", strlen("'MarkerSize',"));
	sprintf(temp, "%f", MarkerSize);
	strncat(plotCommand, temp, strlen(temp));
	strncat(plotCommand, ");", strlen(temp));

	//plot
	if ((ret = engEvalString(eg, plotCommand)) != 0)
	{
		printf("\nplot Command error：%s\n", plotCommand);
		return ret;
	}
	engEvalString(eg, "set(gcf,'color','w');");
	printf("plot Command ok：%s\n", plotCommand);
	//destroy mxArray,but they are still in matlab workspace
	mxDestroyArray(X);
	mxDestroyArray(Y);
	return 0;
}

#include<opencv2\opencv.hpp>
#include "ep_17.h"
#include <tbb/tbb.h>
#include <iostream>
using namespace cv;
/*
ep_1:图像显示
ep_2:图像腐蚀，模糊，边缘检测
ep_3:视频播放，摄像头采集
ep_4:彩色目标追踪
ep_5:光流optical flow
ep_6:点追踪ikdemo
ep_7:人脸识别
ep_8:svm分类
ep_9:无监督分类 
ep_10:生成图片并写入目录
ep_11:图像混合,并设置相对透明度
ep_12:鼠标基本操作
ep_13:格式化输出
ep_14:基本图像绘制
ep_15;访问像素的三种方法及时间消耗
ep_16:利用感兴趣区域进行线性图像混合
ep_17:利用机器学习+神经网络识别车牌数字
ep_18:手写数字识别
*/
int main(int argc, char** argv)
{



	
		
	ep_17();
	return 0;
 }

函数调用：

#include "ep_19.h"
using namespace std;
using namespace cv;

void ep_19()
{
	/*方框滤波
	*第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。
第三个参数，int类型的ddepth，输出图像的深度，-1代表使用原图深度，即src.depth()。
第四个参数，Size类型（对Size类型稍后有讲解）的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第五个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第六个参数，bool类型的normalize，默认值为true，一个标识符，表示内核是否被其区域归一化（normalized）了。
第七个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。

	void boxFilter(InputArray src, OutputArray dst, int ddepth, Size ksize, Point anchor = Point(-1, -1), boolnormalize = true, int borderType = BORDER_DEFAULT)
	*/
	Mat srcimg = imread("girl.jpg");
	Mat boximg;
	boxFilter(srcimg, boximg, -1, Size(3, 3), Point(-1, -1),0);
	namedWindow("源图像", WINDOW_AUTOSIZE);
	imshow("源图像", srcimg);
	namedWindow("方框滤波",WINDOW_AUTOSIZE);
	imshow("方框滤波",boximg);

	/*均值滤波
第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。该函数对通道是独立处理的，且可以处理任意通道数的图片，但需要注意，待处理的图片深度应该为CV_8U, CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型（对Size类型稍后有讲解）的ksize，内核的大小。一般这样写Size( w,h )来表示内核的大小( 其中，w 为像素宽度， h为像素高度)。Size（3,3）就表示3x3的核大小，Size（5,5）就表示5x5的核大小
第四个参数，Point类型的anchor，表示锚点（即被平滑的那个点），注意他有默认值Point(-1,-1)。如果这个点坐标是负值的话，就表示取核的中心为锚点，所以默认值Point(-1,-1)表示这个锚点在核的中心。
第五个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
	void blur(InputArray src, OutputArraydst, Size ksize, Point anchor = Point(-1, -1), int borderType = BORDER_DEFAULT)

	*/
	Mat blurimg;
	blur(srcimg, blurimg, Size(3, 3));
	namedWindow("均值滤波", WINDOW_AUTOSIZE);
	imshow("均值滤波", blurimg);

	/*高斯滤波*/
	/*
	第一个参数，InputArray类型的src，输入图像，即源图像，填Mat类的对象即可。它可以是单独的任意通道数的图片，但需要注意，图片深度应该为CV_8U,CV_16U, CV_16S, CV_32F 以及 CV_64F之一。
第二个参数，OutputArray类型的dst，即目标图像，需要和源图片有一样的尺寸和类型。比如可以用Mat::Clone，以源图片为模板，来初始化得到如假包换的目标图。
第三个参数，Size类型的ksize高斯内核的大小。其中ksize.width和ksize.height可以不同，但他们都必须为正数和奇数。或者，它们可以是零的，它们都是由sigma计算而来。
第四个参数，double类型的sigmaX，表示高斯核函数在X方向的的标准偏差。
第五个参数，double类型的sigmaY，表示高斯核函数在Y方向的的标准偏差。若sigmaY为零，就将它设为sigmaX，如果sigmaX和sigmaY都是0，那么就由ksize.width和ksize.height计算出来。
为了结果的正确性着想，最好是把第三个参数Size，第四个参数sigmaX和第五个参数sigmaY全部指定到。
第六个参数，int类型的borderType，用于推断图像外部像素的某种边界模式。有默认值BORDER_DEFAULT，我们一般不去管它。
 C++: void GaussianBlur(InputArray src,OutputArray dst, Size ksize, double sigmaX, double sigmaY=0, intborderType=BORDER_DEFAULT )
	*/
	Mat gaussimg;
	GaussianBlur(srcimg, gaussimg, Size(3, 3), 0, 0);
	namedWindow("高斯滤波", WINDOW_AUTOSIZE);
	imshow("高斯滤波", gaussimg);
	waitKey(0);                                      
}

源码解析：
文件路径：D:\opencv4.5.1\sources\modules\imgproc\src\box_filter.dispatch.cpp

void boxFilter(InputArray _src, OutputArray _dst, int ddepth,
               Size ksize, Point anchor,
               bool normalize, int borderType)
{
    CV_INSTRUMENT_REGION();

    CV_Assert(!_src.empty());

    CV_OCL_RUN(_dst.isUMat() &&
               (borderType == BORDER_REPLICATE || borderType == BORDER_CONSTANT ||
                borderType == BORDER_REFLECT || borderType == BORDER_REFLECT_101),
               ocl_boxFilter3x3_8UC1(_src, _dst, ddepth, ksize, anchor, borderType, normalize))

    CV_OCL_RUN(_dst.isUMat(), ocl_boxFilter(_src, _dst, ddepth, ksize, anchor, borderType, normalize))

    Mat src = _src.getMat();//读入源图像到临时变量
    int stype = src.type(), sdepth = CV_MAT_DEPTH(stype), cn = CV_MAT_CN(stype);
	//定义int型临时变量，代表源图深度的sdepth，源图通道的引用cn
    if( ddepth < 0 )//如果用户输入的深度小于0，则采用源图深度
        ddepth = sdepth;
    _dst.create( src.size(), CV_MAKETYPE(ddepth, cn) );//使用上方获取的参数初始化目标图
    Mat dst = _dst.getMat();//拷贝目标图的形参Mat数据到临时变量，用于稍后的操作
//处理 borderType不为 BORDER_CONSTANT 且normalize为真的情况
    if( borderType != BORDER_CONSTANT && normalize && (borderType & BORDER_ISOLATED) != 0 )
    {
        if( src.rows == 1 )
            ksize.height = 1;
        if( src.cols == 1 )
            ksize.width = 1;
    }

    Point ofs;
    Size wsz(src.cols, src.rows);
    if(!(borderType&BORDER_ISOLATED))
        src.locateROI( wsz, ofs );

    CALL_HAL(boxFilter, cv_hal_boxFilter, src.ptr(), src.step, dst.ptr(), dst.step, src.cols, src.rows, sdepth, ddepth, cn,
             ofs.x, ofs.y, wsz.width - src.cols - ofs.x, wsz.height - src.rows - ofs.y, ksize.width, ksize.height,
             anchor.x, anchor.y, normalize, borderType&~BORDER_ISOLATED);

    CV_OVX_RUN(true,
               openvx_boxfilter(src, dst, ddepth, ksize, anchor, normalize, borderType))

    //CV_IPP_RUN_FAST(ipp_boxfilter(src, dst, ksize, anchor, normalize, borderType));

    borderType = (borderType&~BORDER_ISOLATED);
 //调用FilterEngine滤波引擎，正式开始滤波操作
    Ptr<FilterEngine> f = createBoxFilter( src.type(), dst.type(),
                        ksize, anchor, normalize, borderType );

    f->apply( src, dst, wsz, ofs );
}

其中，FilterEngine类是OpenCV关于图像滤波的主力军类，OpenCV图像滤波功能的核心引擎。各种滤波函数比如blur， GaussianBlur，到头来其实是就是在函数末尾处定义了一个Ptr类型的f，然后f->apply( src, dst )了一下而已。

这个类可以把几乎是所有的滤波操作施加到图像上。它包含了所有必要的中间缓存器。有很多和滤波相关的create系函数的返回值直接就是Ptr。比如cv::createSeparableLinearFilter(),

cv::createLinearFilter(),cv::createGaussianFilter(), cv::createDerivFilter(),

cv::createBoxFilter() 和cv::createMorphologyFilter().，这里给出其中一个函数的原型吧：
————————————————

Ptr<FilterEngine>createLinearFilter(int srcType, int dstType, InputArray kernel, Point_anchor=Point(-1,-1), double delta=0, int rowBorderType=BORDER_DEFAULT, intcolumnBorderType=-1, const Scalar& borderValue=Scalar() )

/**********************FilterEngine类注释********************************/
//文件路径：D:\opencv4.5.1\sources\modules\imgproc\src\filterengine.hpp
class FilterEngine
{
public:
    //! the default constructor默认构造函数
    FilterEngine();
    //! the full constructor. Either _filter2D or both _rowFilter and _columnFilter must be non-empty.
    //完整构造函数，Either _filter2D or both _rowFilter and _columnFilter必须为非空
    FilterEngine(const Ptr<BaseFilter>& _filter2D,
                 const Ptr<BaseRowFilter>& _rowFilter,
                 const Ptr<BaseColumnFilter>& _columnFilter,
                 int srcType, int dstType, int bufType,
                 int _rowBorderType = BORDER_REPLICATE,
                 int _columnBorderType = -1,
                 const Scalar& _borderValue = Scalar());
    //! the destructor默认析构函数
    virtual ~FilterEngine();
    //! reinitializes the engine. The previously assigned filters are released.重新初始化引擎，清空之前的滤波器申请的内存
    void init(const Ptr<BaseFilter>& _filter2D,
              const Ptr<BaseRowFilter>& _rowFilter,
              const Ptr<BaseColumnFilter>& _columnFilter,
              int srcType, int dstType, int bufType,
              int _rowBorderType = BORDER_REPLICATE,
              int _columnBorderType = -1,
              const Scalar& _borderValue = Scalar());

    //! starts filtering of the specified ROI of an image of size wholeSize.开始对指定了完整尺寸的图片的roi区域进行滤波操作
    virtual int start(const cv::Size &wholeSize, const cv::Size &sz, const cv::Point &ofs);
    //! starts filtering of the specified ROI of the specified image.对指定图片的指定roi区域进行滤波操作
    virtual int start(const Mat& src, const cv::Size &wsz, const cv::Point &ofs);
    //! processes the next srcCount rows of the image.处理图像的下一行
    virtual int proceed(const uchar* src, int srcStep, int srcCount,
                        uchar* dst, int dstStep);
    //! applies filter to the specified ROI of the image. if srcRoi=(0,0,-1,-1), the whole image is filtered.//对图像指定的ROI区域进行滤波操作，若srcRoi=(0,0,-1,-1)，则对整个图像进行滤波操作
    virtual void apply(const Mat& src, Mat& dst, const cv::Size &wsz, const cv::Point &ofs);

    //! returns true if the filter is separable//如果滤波器可分离，则返回true
    bool isSeparable() const { return !filter2D; }
    //! returns the number//返回输入和输出行数
    int remainingInputRows() const;
    int remainingOutputRows() const;
//成员参数定义
    int srcType;
    int dstType;
    int bufType;
    Size ksize;
    Point anchor;
    int maxWidth;
    Size wholeSize;
    Rect roi;
    int dx1;
    int dx2;
    int rowBorderType;
    int columnBorderType;
    std::vector<int> borderTab;
    int borderElemSize;
    std::vector<uchar> ringBuf;
    std::vector<uchar> srcRow;
    std::vector<uchar> constBorderValue;
    std::vector<uchar> constBorderRow;
    int bufStep;
    int startY;
    int startY0;
    int endY;
    int rowCount;
    int dstY;
    std::vector<uchar*> rows;

    Ptr<BaseFilter> filter2D;
    Ptr<BaseRowFilter> rowFilter;
    Ptr<BaseColumnFilter> columnFilter;
};

Szie类：

typedef Size_<int> Size2i;
typedef Size2i Size;

Size_、Size2i、Size这三个类型名等价

//-----------------------------------【Size_类中文注释版源代码】----------------------------
//     代码作用：作为尺寸相关数据结构的Size_ 模板类
//     说明：以下代码为来自于计算机开源视觉库OpenCV的官方源代码
//     OpenCV源代码版本：2.4.8
//     源码路径：…\opencv\sources\modules\core\include\opencv2\core\core.hpp
//     源文件中如下代码的起始行数：816行
//     中文注释by浅墨
//--------------------------------------------------------------------------------------------------------
template<typename _Tp> class Size_
{
public:
   typedef _Tp value_type;
 
   //不同的构造函数定义
   Size_();
   Size_(_Tp _width, _Tp _height);
   Size_(const Size_& sz);
   Size_(const CvSize& sz);
   Size_(const CvSize2D32f& sz);
   Size_(const Point_<_Tp>& pt);
 //例如，Size(5,5),构造出的类型的宽和高都为5
   Size_& operator = (const Size_& sz);
   //区域(width*height)
   _Tp area() const;
 
   //转化另一种数据类型。
    template<typename_Tp2> operator Size_<_Tp2>() const;
 
   //转换为旧式的OpenCV类型.
   operator CvSize() const;
   operator CvSize2D32f() const;
 
   _Tp width, height; //宽度和高度，常用属性
};