精华内容
下载资源
问答
  • 奥维地图如何绘制轨迹
    千次阅读
    2020-12-19 14:06:53

    【www.520z-2.com - 话题作文】

    篇一:《手机奥维互动地图使用经验以及操作指南》

    手机奥维互动地图使用经验以及操作指南(支持IOS、Android、WP8)

    作者:[路游]

    (@[路游],若介意侵权请联系,告知后立即删除)

    来源:新丝路

    链接:

    从今年3月开始接受小羊军团16期领队培训班培训至今,收获颇多。特别是听了獬豸老师讲的OruxMaps户外全功能地图软件使用,发现手机GPS地图的应用真可谓是户外运动的神器。不过今天的重点不是讲解OruxMaps,有关信息请在大厅搜索獬豸老师的帖子、胡狼老师的帖子和16期领队班狼牙的入门贴子,他们的更加专业。

    之所以要介绍奥维互动地图给大家,是因为目前为止OruxMaps软件只支持Android手机操作系统,我的手机操作系统是Windows Phone 8,无奈之下在网上查找替代品。又无意间,从手机应用商店中发现了另一款可替代OruxMaps的神器——奥维互动地图。它不但支持Android,还支持IOS,Windows Phone等。所以拥有苹果手机的朋友也可以抱着这个地图笑了。

    我安装的是Windows Phone 8版本的奥维地图,IOS和Android版本比WP8的功能要多一些,好用一些,不过只要能在WP8上使用我就阿弥陀佛了。废话少说,我用WP8版本演示,先给大家一些截屏,大家大概浏览一下。

    正式介绍开始:

    奥维互动地图浏览器是由国人团队制作的一款全功能全平台的地图应用,最新版收录了8大地图数据源,并且还在不断增加。它是一款集定位指南、语音导航、位置分享、轨迹记录、实时路况等功能于一体的互动地图。软件是免费的,目前来说我使用的免费版本没有任何问题,但是如果成为收费VIP会员将有更多的方便,和更大的云存储空间,后面会谈到。

    这里主要讲讲和户外徒步相关的一些功能,分两个部分介绍给大家。其他的功能大家可以自己去实验。

    第一部分:软件主要功能介绍,地图选择、定位指南、打点和轨迹。{奥维地图如何绘制轨迹}.

    上图说明了地图切换的方法。在地图左上角点击“地图设置”图标,然后在“地图设置”中选择地图源,下方的“浏览地图”可以选择在线或离线浏览方式。

    大家注意到左边截屏中地图切换按钮下方,显示一个数字13,意思是这个是第13层(级)的图片。点击下方的“-”或“+”可以调整地图层数,数值越大地图细节越清楚。当然,大家如果不停的用手机流量下载地图,没多久手机流量就用光了。如果你的手机包月的数据流量超级大,那就无所谓了。像我这种每个月都精打细算要数数据流量的人来说,下载离线地图就很必要,我下载了乌鲁木齐区域的地图一共441.9MB,还只下载到14层图。到户外没有网络的情况下,也下载不成,所以不管手机流量够不够用,还是先下载离线地图吧。

    下面介绍怎么下载离线地图,点击右下角的“更多”按钮。{奥维地图如何绘制轨迹}.

    上图中的右侧屏幕是下载界面。首先点“选择区域”,通过系统区域菜单找到要下载的区域,然后选择地图类型和级别,选择级数越大地图越多下载时间越长,如果是VIP会员可以提高下载速度,这就是交钱的好处,好像12元钱是3个月的费用,富裕的朋友也可以支持一下。

    定位:点击左下角“定位”,如果有GPS信号,就可以找到当前的地图坐标位置。再次点击可以打开以当前位置为中心,手机为方向的指北针。可以很容易知道自己的方位以及朝向。

    打点:在地图上按住屏幕2秒,会弹出“打点”的编辑框。该位置将被打上坐标点。请看下面的图片介绍:{奥维地图如何绘制轨迹}.

    如图,可以为这个点添加很多属性,比如名称、分组、风格、图标样式,还可以将查看该点的经纬度和高度,可以分享给好友或做为导航的起点和终点。这个坐标点不想要的话就点最下面的删除。

    GPS轨迹、区域、画线:

    点击左侧边上的GPS按钮,在界面中可以开启GPS轨迹。

    篇二:《奥维地图查勘使用说明》

    奥维地图使用说明

    由于奥维地图支持谷歌地球KML图层导入、、距离测算、经纬度方位角信息采集和谷歌卫星地图等多种地图离线浏览,对我们查勘站点有很大帮组,所以建议查勘的时候备上此软件(本次以安卓手机为例)

    奥维地图主界面

    1, 地图离线下载

    运行奥维地图

    点击更多

    点击下载地图

    地图类型有很多种,建议选择Google

    卫星混合图,这种地图是google卫星地图和google地图的路网数据混合而成,可以看到环境情况和道路情况(由于国内google卫星地图的数据都不是最新的,请以现场实际情况为准)

    ,地图级别表示的是清晰度,越大越清晰,但是地图数据量也就越大。默认

    即可。系统区域选择默认。

    以成都为例

    选择保存后会弹出界面,点击下载

    先计算大小

    照刚才的默认等级来下载,数据量约为454MB(左侧),如果将地图等级提高到最高,,系统区域选择郊区和城区一样处理(右侧),所需要下载的数据是非常大的,所以为了得到清晰的地图,可以在查勘前导入kml后,手动放大当天需要查勘的站点的周围地图,这样也可以离线地图。

    导入导出图层

    1, 生成kml

    kml.xls

    A列站名,B列经度,C列纬度。Sheet名称为生成图层名称,我测试过,用部分kml生成工具生成的谷歌图层无法在奥维中无法识别,这样请在谷歌地球打开该图层然后在谷歌地球重新导出为kml。 2, 导入kml

    a) 运行奥维

    b) 选择数据管理

    c) 导入导出标记

    d) 从文件导入

    篇三:《奥维地图常用问题集锦综合》

    奥维地图常用问题集锦综合

    1、安卓手机里如何添加kml等文件?

    Android4.4.2以后,数据目录放到SD卡下的

    Android/data/com.ovital.ovitalMap/files/omap之下。(安卓手机中若是找不到对应的文件夹,可以通过断开电脑连接,重新启动手机,再连接电脑就可以发现对应的文件夹了)

    4.4.2之前的安卓系统,则把文件放到SD卡下面的omap目录里。之后,运行手机奥维,点【更多】——【数据管理】——【导入导出标记】,进行导入。

    2、苹果手机里如何导入kml、kmz、ovobj等文件等?

    将kmz文件通过itunes拷到手机上,然后打开奥维地图,点【更多】-》数据管理-》导入导出标记中导入。

    如果不会通过itunes拷文件,也可以在PC上装个PC版本的奥维地图,将kmz文件直接拖入奥维地图即可导入,之后再同步到手机上。

    将kml文件发到邮箱中,在苹果手机上打开邮箱找到该kml,点击该文件,选择用奥维地图打开。也可以用qq接收,下载后用奥维打开。

    注意:前提是,奥维软件得回到主页面才行。

    篇四:《将CAD导入奥维地图中》

    1. 打开奥维互动地图,登录,

    2. 在CAD和奥维地图中找到一个公共点。

    3. 在奥维中的“公共点”处点击右键,在弹出的菜单中选“添加标签”

    4. 点击“添加标签”后,会出现一对话框:

    5. 在“标签设置”对话框中填写如下内容:

    A. 名称:可任意填写,如填写“CAD”

    B.

    C. 在“备注”中填写“公共点”的CDA坐标(注意,是CAD坐标,不是测量坐标){奥维地图如何绘制轨迹}.

    D. 单击“添加到收藏夹”

    6.此时奥维地图中就出现了一个标签:

    6. 把要插入的CAD图另存为DXF格式的文件。

    7. 把DXF文件拖到奥维地图中,会出现一对话框:

    选:

    点击“设置”,出现:

    点击“选择标签”,出现:{奥维地图如何绘制轨迹}.

    选择“CAD”后,点击“确定”

    再次点击“确定”后,出现:

    点击“关联点管理”,然后在“名称”下面打勾,确定:{奥维地图如何绘制轨迹}.

    在CAD坐标设置中,选择“关联点转换坐标”,然后点击“开始解析”,稍等,解析完的出现:

    点击“导入”:

    导入成功后,CAD图就会出现在奥维地图中了:

    公共点的选择关系到插入后的精度;

    插入对象的多少和奥维VIP的等级有关;

    如果插入后提示成功,但奥维中却没有,说明插入的对象多了。

    篇五:《奥维互动地图经纬度采集手册iPhone版》

    “奥维互动地图”软件,采集学校海

    拔、坐标信息操作手册

    一、安装“奥维互动地图”。

    二、进入地图,点击地图下方第四个 “我在这”按钮。

    三、点击“生成当前位置的奥维签名标签”点击左上角“关闭”按钮

    四、点击下方第三个“收藏”按钮,再选择“Sign001”。

    五、点击下方第一个“定位”按钮,读取屏幕上的纬度、经度、海拔。

    更多相关内容
  • 学校表现、智力和强化控制轨迹量表 学校表现、智力和 GUNARS REIMANIS 康宁社区学院强化控制量表的轨迹 最近人们对强化控制轨迹的含义及其与教育的关系产生了浓厚的兴趣。 从控制轨迹理论可以预测出一种积极的内部...
  • 辽阳县一高中师生员工和共同居住人健康状况、行程轨迹日报表.xlsx
  • 吉林省长春市第一零八学校初中语文 成长的轨迹学生作文素材.doc
  • 自由落体运动轨迹

    2015-12-01 23:09:14
    学校做的一个作业,用数值积分法实现自由落体运动轨迹,考虑了空气阻力影响,可以供相关专业参考
  • 有风险的小学生的控制取向轨迹中的性别、种族和年级差异 84 John R. Slate 和 David Chick SHERRETS, S., G m , G., ~r LANGNER, H. (1979)。 WISC 协议书写错误的频率。 心理学 WARREN, S.,考官在个人智力测试中...
  • 控制轨迹和成就动机——教育心理学中的关键因素 控制轨迹和成就动机——教育心理学中的关键因素 KENYON S. CHAN 加州大学洛杉矶分校 本文的目的是检验研究对教育心理学轨迹的影响实践教育心理学家的控制和成就动机。...
  • 一定要备注:研究方向+学校/公司+昵称,例如:”3D视觉 + 上海交大 + 静静“。请按照格式备注,可快速被通过且邀请进群。原创投稿也请联系。 ▲长按加微信群或投稿 ▲长按关注公众号 3D视觉从入门到精通知识星球:...

    点击上方“3D视觉工坊”,选择“星标”

    干货第一时间送达

    78702fbabdcbaea55d0ec90602a9c201.png

    作者丨paopaoslam

    来源丨 泡泡机器人SLAM

    标题:CLINS: Continuous-Time Trajectory Estimation for LiDAR-Inertial System

    作者:Jiajun Lv1, Kewei Hu1, Jinhong Xu, Yong Liu, Xiushui Ma, Xingxing Zuo

    来源:IROS 2021

    编译:曹明

    审阅:lionheart

    摘要

    0ec5b09ec188e65e9ea38e9a9c3e3ae1.png

    在这篇文章中,我们提出了一个用于SLAM的准确度极高的连续时间轨迹估计框架。它能够高效地融合高频率与不同步的传感器信息。我们在一个3D激光-惯性系统下使用了这一套框架来验证其效果。本文提出的方法使用了非刚体配准的方法来进行连续时间的轨迹预测,同时来进行激光雷达的点云畸变矫正。除此之外,当回环检测发生时,我们还提出了一个两阶段的轨迹矫正方法,来高效的解决比较耗时的全局优化问题。我们在几个公开的数据集以及我们自己采集的数据上都测试了我们的方法。实验的结果表明了当激烈的运动发生时,我们的方法优于离散时间估计的方法。此外,我们还开源了代码以给研究社区做出贡献。

    9baa622a307ef3cb5f681d3687eaa0a2.png

    主要贡献

    8c8c8b3cc1ac6054a0d83a87f6916cf8.png

    1. 提出了一个连续时间的轨迹估计器,支持融合3D激光雷达的数据与IMU的数据,并且很容易将其扩展,使得其能够融合其他不同频率的传感器信息。

    2. 提出了一个两阶段的轨迹矫正方法来有效的解决回环检测时的计算量问题。

    3. 所提出的方法在几个公开的数据集以及我们采集的数据集上进行了验证,并且跟其他SOTA的方法进行比较。我们还开源了代码。据我们所知,这是第一份开源的连续时间的激光-惯性轨迹估计器的工作。

    be1b8ecceba8f70e2930deba02802dee.png

    连续时间的轨迹表示方法

    b264361c8bc79098124795e5414dc961.png

    离散时间的轨迹优化方法是直接针对机器人的离散时间的轨迹点来进行位姿图优化。

    连续时间的轨迹优化方法不直接对机器人的轨迹点进行优化,而是将机器人的轨迹用B样条来拟合,并且通过调整B样条的控制点的位置使得轨迹尽可能贴合观测。

    本文采用两组B样条控制点,分别拟合机器人的旋转与平移在时间上的轨迹。

    e51e1d4c62a7cd96e6d943ceadaac47f.png

    方法论

    ec686be498e80d2d4b73fa2915c17332.png

    A. 时序图

    本文提出的方法所采用的方案的时序图如图所示。该方法采用的是三次B样条,并且以固定的时间间隔来插入控制点。在当前帧的点云的数据采集周期之内的段(segment)为活跃段(Active Segments),而影响活跃段的控制点,定义为活跃的控制点(蓝色与红色的点),对应的B样条基函数为活跃基函数(图中蓝色曲线和红色曲线)。受到活跃基函数影响的除了活跃段之外的段,称之为静态段,对应的控制点与基函数称之为静态曲线与静态基函数。

    0995e5dc7de1a58c50c57d2ed69ce2b0.png

    B. 初始化

    一帧新的激光雷达点云被采集时,根据设定的时间频率,已经有一定数量的控制点被加入以控制机器人的当前的轨迹。对此,先将该时间段内的IMU数据进行旋转、位置以及速度上的积分,然后调整控制点的位置,使得B样条插值出来的旋转、位移以及速度符合IMU积分的结果。其优化的目标函数为

    cf17d15ee0516ab80e053454e4604831.png

    C. 局部窗口内的非刚体变换配准

    由于激光雷达在一帧点云的采集时间之内,由于外部运动,会导致点云畸变的产生。产生畸变的点云就不再是可以用刚体变换来描述的了,因此传统的刚体配准方法(ICP, NDT)往往会带来误差。本文由于使用B样条拟合轨迹,因此可以插值出任意时刻的速度与位姿。利用其位姿来将点云内的每一个点还原到k时刻激光雷达的坐标系下,其公式为

    276b3cb719a9bb16793163aedf5a22e8.png

    本文的位姿优化是在一个局部窗口中,该局部窗口由关键帧组成。关键帧的选取准则为机器人的位姿变换超出了设置的阈值。每当一帧新的点云获取时,会将其提取LOAM的面点与特征点,并且与局部地图的最近点来做关联。

    在一些退化的场景下,IMU的信息是不受影响的。因此我们紧耦合了IMU的测量与激光雷达的特征来进行轨迹的约束。本文的目标函数为:

    a9ae25d900e2f142e49df529f20c417d.png

    这三个残差项的定义为

    aeeb4cab7931a9de7e4daa047cbd6fd6.png

    其中,公式(7)表示将边缘点以及面点投影后的残差。公式(8)表示优化出来的位姿相对于IMU加速度的残差,公式(9)表示优化出来的位姿相对于角速度的残差。

    当回环检测发生时,直接对连续轨迹的控制点进行优化是非常耗时的,因此本文提出了一种两阶段的优化策略。

    在阶段一,当回环被检测到时,对对应的位姿进行图优化来消除累积误差,这种方法与传统的离散的方法(如LIO-SAM)类似。

    在阶段二,对影响阶段1的轨迹的那些控制点来进行优化,使得轨迹能够更好的贴合阶段1得到的优化后的位姿。阶段二的目标函数为:

    bb1db64c0c7a9c92e242ccea55d03ae1.png

    620397c3f6b97feb4092edad5890851e.png

    实验

    be6c6d19d6cfefc6ca61ba211464441b.png

    A. 室内场景的轨迹估计

    在公开数据集上验证了本文提出的方法的唯一与旋转的均方根误差,相较于其他的激光雷达-惯性系统的结果。

    177313a290f067984de25371aa791165.png

    B.大规模场景的轨迹预测与场景建图

    在公开数据集以及校园场景下的数据集的一个结果验证。建图效果如图所示。

    888ca61b80b2b40076d8cee9811e4525.png

    cd8f0e5884e3d384e6a37c3a895e7588.png

    Abstract

    Abstract—In this paper, we propose a highly accurate continuous-time trajectory estimation framework dedicated to SLAM (Simultaneous Localization and Mapping) applications, which enables fuse high-frequency and asynchronous sensor data effectively. We apply the proposed framework in a 3D LiDAR-inertial system for evaluations. The proposed method adopts a non-rigid registration method for continuous-time trajectory estimation and simultaneously removing the motion distortion in LiDAR scans. Additionally, we propose a two- state continuous-time trajectory correction method to efficiently and efficiently tackle the computationally-intractable global optimization problem when loop closure happens. We examine the accuracy of the proposed approach on several publicly available datasets and the data we collected. The experimental results indicate that the proposed method outperforms the discrete-time methods regarding accuracy especially when ag- gressive motion occurs. Furthermore, we open source our code at https://github.com/APRIL-ZJU/clins to benefit re- search community.

    本文仅做学术分享,如有侵权,请联系删文。

    3D视觉精品课程推荐:

    1.面向自动驾驶领域的多传感器数据融合技术

    2.面向自动驾驶领域的3D点云目标检测全栈学习路线!(单模态+多模态/数据+代码)
    3.彻底搞透视觉三维重建:原理剖析、代码讲解、及优化改进
    4.国内首个面向工业级实战的点云处理课程
    5.激光-视觉-IMU-GPS融合SLAM算法梳理和代码讲解
    6.彻底搞懂视觉-惯性SLAM:基于VINS-Fusion正式开课啦
    7.彻底搞懂基于LOAM框架的3D激光SLAM: 源码剖析到算法优化
    8.彻底剖析室内、室外激光SLAM关键算法原理、代码和实战(cartographer+LOAM +LIO-SAM)

    9.从零搭建一套结构光3D重建系统[理论+源码+实践]

    10.单目深度估计方法:算法梳理与代码实现

    11.自动驾驶中的深度学习模型部署实战

    12.相机模型与标定(单目+双目+鱼眼)

    重磅!3DCVer-学术论文写作投稿 交流群已成立

    扫码添加小助手微信,可申请加入3D视觉工坊-学术论文写作与投稿 微信交流群,旨在交流顶会、顶刊、SCI、EI等写作与投稿事宜。

    同时也可申请加入我们的细分方向交流群,目前主要有3D视觉CV&深度学习SLAM三维重建点云后处理自动驾驶、多传感器融合、CV入门、三维测量、VR/AR、3D人脸识别、医疗影像、缺陷检测、行人重识别、目标跟踪、视觉产品落地、视觉竞赛、车牌识别、硬件选型、学术交流、求职交流、ORB-SLAM系列源码交流、深度估计等微信群。

    一定要备注:研究方向+学校/公司+昵称,例如:”3D视觉 + 上海交大 + 静静“。请按照格式备注,可快速被通过且邀请进群。原创投稿也请联系。

    197ffeb870f1ee7ef502cba142ada689.png

    ▲长按加微信群或投稿

    7b6f41b44a56cd6ee760c9d0c50ee3d9.png

    ▲长按关注公众号

    3D视觉从入门到精通知识星球:针对3D视觉领域的视频课程(三维重建系列三维点云系列结构光系列手眼标定相机标定激光/视觉SLAM自动驾驶等)、知识点汇总、入门进阶学习路线、最新paper分享、疑问解答五个方面进行深耕,更有各类大厂的算法工程人员进行技术指导。与此同时,星球将联合知名企业发布3D视觉相关算法开发岗位以及项目对接信息,打造成集技术与就业为一体的铁杆粉丝聚集区,近4000星球成员为创造更好的AI世界共同进步,知识星球入口:

    学习3D视觉核心技术,扫描查看介绍,3天内无条件退款

    fe4d38223aaba27c280dc92d9cb8328b.png

     圈里有高质量教程资料、答疑解惑、助你高效解决问题

    觉得有用,麻烦给个赞和在看~  

    展开全文
  • 通过对这些数据的分析、判断,对学校的发展轨迹进行实行的修正和提高,对教师的职业成长和学生的成绩及行为提高起到助推作用。这些数据的收集,是在日常的工作、学习和生活中不知不觉积累下来的,不增加老师的工作...
  • Android基于在线地图的轨迹跟踪服务

    千次阅读 2021-07-11 13:37:57
    自我思考,特别是在今年这种特殊的背景环境之下,即使不能在学校进行教课学习但我们仍然听课不停学,克服困难坚持学习下去,首先我认为我选择这题是有一定难度的,即使老师讲过相关的练习,我觉得是这次实训更是延伸...

      该项目为大二下学期androidweb课前老师布置的一个地图轨迹跟踪的作业,主要运用了百度地图的SDK进行相关的定位,以及实现轨迹跟踪的功能。

    一、项目展示

    二、项目背景

      为了提高学生对androidweb课程的编写能力而进行的项目实训作业,不仅能够把握学生对课程的了解程度而且能够提高学生的编程能力这对我们学习这门课程是很有必要的,进行这次项目实训不仅能够锻炼我们的思维还能为我们之后更进一步深度学习提供了基础保障,于是老师布置了不同的项目实训作业供我们选择,以便我们用这个学期学来的知识进行更深刻的巩固,且按照老师的要求进行作业。
      通过前期的查阅资料与调查学习,通过查阅资料,分析数据,掌握如今人们使用智能手机的情况和使用地图软件进行导航和其他功能的情况。通过学习使用百度地图的开发接口和安卓的开发知识来为中期开发软件编码做好准备。
      在如今高智能机普及率的背景下,所有人出门几乎都会使用到智能手机的地图。一款方便快捷的记录轨迹的app,可以方便地记录人们出现的运动轨迹。让人们掌握有用的信息来运用与生活之中开发。
      2015年全世界智能手机用户比例第一次超过世界人口的十分之一,到2018年,世界上三分之一的消费者成为智能手机用户,总数超过 25.6亿人。其中安卓智能手机占了绝大多数。而在中国,中国城市智能手机的普及率很大的提高,从2012年的33%上升至47%,近一半的中国城市居民已经拥有智能手机。其中,69%的用户每天都会使用智能手机访问互联网,这个比例要高于美国的智能手机用户。加上人们对自身身体素质要求的提高,想要记录自己的运动路线进行打卡的需求,所以衍生了该款在线地图轨迹跟踪服务APP的诞生,该款APP不仅满足了人们自身对打卡的需求也可记录自己身边亲人的运动轨迹防止走丢,也可实时定位用户的当前位置,满足人们出行的方便与快捷。

    三、项目需求分析

      设计一款可以应用于在线地图轨迹重现的安卓APP,在硬件上需要一台安卓系统的可以应用GPS定位的手持设备。
    用户在初次使用时记录轨迹时需要进行注册,通过注册的用户查询该用户记录的运动轨迹,一个用户对应自己所记录的轨迹,通过登录即可定位并查询该用户记录的运动的所有轨迹。
      用户也可以对自己之前自己所记录的运动轨迹进行删除。
      程序运行的时候,要求能够实时的记录运动中的GPS经纬点数据,创建数据表,并存储,然后通过调用程序中保存好的轨迹数据,通过点与点相连,连接成一条轨迹,实现轨迹的实时记录。
      为了提高程序的可用性、人性化,在UI设计方面需要做的更好一些,要比类似的市场中的GPS记录程序更加的吸引用户,还需要提高软件的交互性,来留住用户。

    1、界面需求

      根据需求UI设计了登录注册界面、一个主界面,一个历史记录查询界面。
      登录注册界面:分为欢迎界面、登录界面和注册界面。
      主界面:主界面分为三个模块,分别是首页定位模块、跑步模块和我的模块。
    ①首页定位模块:这个模块由一个MapView组成,这个MapView用来展示当前用户的位置。
    ②轨迹模块:这个模块实时显示用户的跑步轨迹,这个模块由MapView和Button组成。MapView用来展示实时的运动轨迹。Button用来设置开始跑步和停止跑步。
    ③信息模块:这个模块由图片和两个Button组成,点击第一个按钮可以进入查看历史轨迹模块。第二个按钮可以退出程序。
    历史轨迹界面:
    历史轨迹界面由MapView和Button组成,点击Button可以选择要查询的日期。如果当天日期有运动记录则会在MapView上面显示出来。

    2、功能需求

      在信息高速流动的现代社会,移动设备凭借其便于携带和随时随地收发信息的优点,成为了大多数人生活中必要的娱乐和通讯工具。而在手机移动网络所提供的大量服务中,基于在线地图的地位服务已经成为了一项实用的新型业务。它可以通过移动端的定位技术,提供给用户和位置相关的信息,满足不同用户的需求做出一个记录人们走动轨迹的基于Android系统的平台,方便人们知道的自己的日常走动情况。记录每次的走动的轨迹。开发一个界面简单清晰,UI友好易懂,而且无赘余功能的运动平台。
      设计一款可以应用于在线地图轨迹重现的安卓APP,在硬件上需要一台安卓系统的可以应用GPS定位的手持设备。
      程序运行的时候,要求能够实时的记录运动中的GPS经纬点数据,创建数据表,并存储,然后通过调用程序中保存好的轨迹数据,通过点与点相连,连接成一条轨迹,实现轨迹的实时记录。
      为了提高程序的可用性、人性化,在UI设计方面需要做的更好一些,要比类似的市场中的GPS记录程序更加的吸引用户。
    并能够满足用户使用程序安全性高、响应速度快、信息处理速度快。没有出现卡顿或导致死机现象,使用起来便捷。
      安卓平台的优势与体系框架,详细介绍了安卓应用程序开发设计的关键技术以及应用程序的开发流程。然后,通过对手机网络地图现状的分析,结合了百度地图与其API库设计出一个基于Android的在线地图轨迹跟踪服务。该系统在实现在线地图一般功能的基础上,可以根据用户定位信息实时监测和记录用户移动路线,随时显示在手机的在线地图上面,并且可以查询到历史轨迹的记录。
      该系统的使用需要填写注册用户信息并登录即可使用记录轨迹的相关功能,能够动态的记录自己的运动轨迹,能够实时记录当前登录设备的位置通过三个页面转换进行功能操作,如果需要进行轨迹的记录需要点击轨迹图标,进入该页面之后点击开启轨迹服务即可记录该用户的运动轨迹,再点击开启跟踪服务后,系统会自动定位到当前位置,并开始轨迹的记录绘制,如果需要查询历史轨迹则点开“我的”,然后点击“查看记录”,此功能可以查看不同日期该用户的运动轨迹,当用户想更换其他用户账号时可按“我的”然后点击“退出”即可完成此操作。

    三、项目设计

    1、系统数据库设计

      android数据库采用的是SQLite的存储形式,对应数据库的设计是关乎整个项目的重中之重,对于存储用户信息的安全性,系统运转的流通起到了重要的作用,本次项目中的数据库设计符合本次项目实训的要求,支撑整个项目的信息,下面我将展示在本次实训中用到的表的作用和组成。
    (1)用户信息表
    用户信息表T_infoxxd用来保存用户的基础个人信息。结构如表3.1所示:
                            表3.1用户信息表T_infoxxd

    字段名称数据类型长度是否允许为空是否为主键字段描述
    id_xxd bigint auto 用户id
    Uid_xxd varchar 50 识别标示符
    name_xxd varchar 20 用户名
    password_xxd varchar 6 密码

    四、项目功能代码

    github完整项目代码:https://github.com/xxd6772123/MapXxd35_418

    五、总结

    在这次androidweb实训中,我学会了自我学习,自我思考,特别是在今年这种特殊的背景环境之下,即使不能在学校进行教课学习但我们仍然听课不停学,克服困难坚持学习下去,首先我认为我选择这题是有一定难度的,即使老师讲过相关的练习,我觉得是这次实训更是延伸于上一次的练习,而且对于这次实训,看到了这个题目我认为是有价值的,所以选择了去做,而且这一次的实训不仅只是android客户端还结合了web服务端这让我们结合了我们所学的内容进行实践与运用。

    如果你觉得我这篇文章不错或者帮助到了你可以在本篇文章中给我点一个赞,您的小小鼓励,将会是我在敲码路上的大大动力!!!!

    展开全文
  • 05轨迹规划基础 ----笛卡尔空间轨迹规划插值代码

    千次阅读 多人点赞 2021-01-30 16:05:25
    但是我后来顿悟了,我是为了了解笛卡尔空间轨迹规划过程中的插值原理,尤其是四元数用于姿态的插值!我最终探讨的问题是: 如何实验笛卡尔空间下直线和圆弧的轨迹规划 并且在关节空间保证速度、加速度、加加速度的...

    0.前言

    我今早陷入了沉思,我想不起自己为啥要写一个逆运算包括今天这个笛卡尔空间位置和姿态插值的代码了,我在VS2019里进行仿真也不现实,我想用matlab仿真那为啥不用
    matlab语言写,更何况我的毕设是在ros平台下仿真的!
    但是我后来顿悟了,我是为了了解笛卡尔空间轨迹规划过程中的插值原理,尤其是四元数用于姿态的插值!我最终探讨的问题是:
    如何实验笛卡尔空间下直线和圆弧的轨迹规划
    并且在关节空间保证速度、加速度、加加速度的光滑!
    PS:如果你不在乎原理,建议直接打开ROS 的 catkin_UR功能包进行使用!肯定比我写的好~

    1.摘要

    本片文章主要内容是书写笛卡尔空间的轨迹规划(PTP),插值部分的代码,输入为Ta,Tb,输出为T1,T2 、、、T100,中间的插值矩阵,实现直线的插值。

    2.数学基础

    2.1旋转矩阵和四元数之间的换算
    公式截图来自博客https://blog.csdn.net/M_try/article/details/82900500
    (这是一篇旋转变换表示换算很完整的博客)

    若已知旋转矩阵R,求四元数[q0 q1 q2 q2]

    \end{bmatrix}
    则对应的四元数为:
    在这里插入图片描述
    这个来自我自己博客嘻嘻

    这个来自我自己博客嘻嘻

    **

    2.2四元数线性插值

    **
    线性插值基本原理: quat_temp = quat1 + s*(quat2 - quat1)
    推荐教材https://www.qiujiawei.com/understanding-quaternions/
    或者其实你不看教材,也不影响这篇文章的阅读,就是高中复数的推广
    我看四元数的插值分为直线,slerp等等,在我本专栏的第二篇文章中有写四元数各种插值的理论

    https://blog.csdn.net/weixin_44168457/article/details/112710515

    但是我这篇文章写的是PTP(点到点),所以我就简单用了线性插值,包括px,py,pz,我也没想明白可以用三次多项式或者三次样条之类,我看matlab用的是三次多项式,估计是增加了二次约束条件(边界速度约束),这个我后边文章应该会写到。

    3代码

    3.1第一部分是不加插值,只进行旋转矩阵的四元数换算

    //笛卡尔空间PTP轨迹规划的位置和姿态插值代码编写
    #include<iostream>
    #include"math.h"
    using namespace  std;
    const double d1 = 0.1273;
    const double a2 = 0.612;
    const double a3 = 0.5723;
    const double d4 = 0.163941;
    const double d5 = 0.1157;
    const double d6 = 0.0922;
    const double ZERO_THRESH = 0.00000001;
    const double PI = 3.1415926;
    void forward(const double* q, double* T) {
        double s1 = sin(*q), c1 = cos(*q); q++;
        double q23 = *q, q234 = *q, s2 = sin(*q), c2 = cos(*q); q++;
        double s3 = sin(*q), c3 = cos(*q); q23 += *q; q234 += *q; q++;
        double s4 = sin(*q), c4 = cos(*q); q234 += *q; q++;
        double s5 = sin(*q), c5 = cos(*q); q++;
        double s6 = sin(*q), c6 = cos(*q);
        double s23 = sin(q23), c23 = cos(q23);
        double s234 = sin(q234), c234 = cos(q234);
    
        *T = c6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * s6; T++;  //nx
        *T = -s6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * c6; T++;  //Ox
        *T = -(c234 * c1 * s5 - c5 * s1); T++;//ax
        *T = -(d6 * c234 * c1 * s5 - a3 * c23 * c1 - a2 * c1 * c2 - d6 * c5 * s1 - d5 * s234 * c1 - d4 * s1); T++;//Px
    
        *T = -c6 * (c1 * s5 - c234 * c5 * s1) - s234 * s1 * s6; T++;//ny
        *T = s6 * (c1 * s5 - c234 * c5 * s1) - s234 * c6 * s1; T++;//Oy
        *T = -(c1 * c5 + c234 * s1 * s5); T++;//ay
        *T = -(d6 * (c1 * c5 + c234 * s1 * s5) + d4 * c1 - a3 * c23 * s1 - a2 * c2 * s1 - d5 * s234 * s1); T++;//py
    
    
        *T = -(-c234 * s6 - s234 * c5 * c6); T++;//nz
        *T = -(s234 * c5 * s6 - c234 * c6); T++;//oz
        *T = -s234 * s5; T++;//az
        *T = d1 + a3 * s23 + a2 * s2 - d5 * (c23 * c4 - s23 * s4) - d6 * s5 * (c23 * s4 + s23 * c4); T++;//Pz
        *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
    }
    void OuputT(double t[4][4])
    
    {
        
        
        cout << "输出矩阵T:   " << endl;
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                cout << t[i][j] << "      ";
            }
            cout << endl;
        }
    }
    void OuputQuat(double quat[4])
    
    {
        cout << "四元数quat:" << " [  " << quat[0] << "   " << quat[1] << "   " << quat[2] << "   " << quat[3] << "  ] " << endl;
    
       
    }
    void Quat_to_Dcm(double quat[4], double* T)
    {
        double q0 = quat[0], q1 = quat[1],q2 = quat[2] ,q3 = quat[3];
        *T = q0*q0+q1*q1-q2*q2-q3*q3; T++;  //T00
        *T = 2*(q1*q2 - q0*q3); T++;  //T01
        *T = 2 * (q1 * q3 + q0 * q2); T++;//T02
        *T = 0; T++;//Px
    
        *T = 2 * (q1 * q2 +q0 * q3); T++;//ny  T10
        *T = q0 * q0 +-q1 * q1 + q2 * q2 - q3 * q3; T++;//Oy   T11
        *T = 2 * (q2 * q3 - q0 * q1); T++;//ay   T12
        *T = 0; T++;//py
    
    
        *T = 2 * (q1 * q3 - q0 * q2); T++;//nz  T20
        *T = 2 * (q3 * q2 + q0 * q1); T++;//oz   T21
        *T = q0 * q0 + -q1 * q1 - q2 * q2 +q3 * q3; T++;//az  T22
        *T = 0; T++;//Pz
        *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
    }
    void Dcm_to_Quat(double T[4][4],double * Quat)
    {
        double q0, q1, q2, q3;
        q0 = 0.5 * sqrt(1 + T[0][0] + T[1][1] + T[2][2]);
        q1 = (T[2][1] - T[1][2]) / (4 * q0);
        q2 = (T[0][2] - T[2][0]) / (4 * q0);
        q3 = (T[1][0] - T[0][1]) / (4 * q0);
        *Quat = q0; Quat++;  *Quat = q1; Quat++;  *Quat=q2; Quat++; *Quat = q3;
    
    
    }
    void Ctraj(double T1, double T2, int t)
    {
        cout << endl;
    }
    int main()
    
    {
        double quat[4];//quat为四元数
    	double q[6] = { 0.1 ,0.2,0.3,0.4,0.5,0.6 };//q为关节角度
        double t[4][4];
        double* T, * Q,* Quat;
        T = &t[0][0];
        Q = &q[0];
        Quat = &quat[0];
        forward(Q, T);//手打矩阵T过于麻烦,所以我还是用正运动学根据q算出来的
        OuputT(t);//相对于上一篇博客,这里我把矩阵和数组的打印都封装为函数了
        Dcm_to_Quat(t, Quat);
        OuputQuat(quat);
        Quat_to_Dcm(quat,T);
        OuputT(t);
    }
    

    运行结果

    输出由q 进行正运动学结果T:
    0.0473957      -0.976785      -0.208915      1.18382
    -0.392918      0.174058      -0.90295      -0.127305
    0.918351      0.124882      -0.375547      0.416715
    0      0      0      1
    四元数quat: [  0.459866   0.558768   -0.612823   0.317411  ]
    输出四元数计算得到的旋转矩阵T:
    0.0473957      -0.976785      -0.208915      0
    -0.392918      0.174058      -0.90295        0
    0.918351      0.124882      -0.375547        0
    0      0      0      1
    

    可以看出来位置矩阵我还没加上 Px,Py,Pz位置是0,下边插值算法中会加上的哈~
    3.2完整版插值代码

    //笛卡尔空间PTP轨迹规划的位置和姿态插值代码编写
    #include<iostream>
    #include"math.h"
    using namespace  std;
    const double d1 = 0.1273;
    const double a2 = 0.612;
    const double a3 = 0.5723;
    const double d4 = 0.163941;
    const double d5 = 0.1157;
    const double d6 = 0.0922;
    const double ZERO_THRESH = 0.00000001;
    const double PI = 3.1415926;
    int SIGN(double x)
    {
        return (x > 0) - (x < 0);
    }
    void forward(const double* q, double* T) {
        double s1 = sin(*q), c1 = cos(*q); q++;
        double q23 = *q, q234 = *q, s2 = sin(*q), c2 = cos(*q); q++;
        double s3 = sin(*q), c3 = cos(*q); q23 += *q; q234 += *q; q++;
        double s4 = sin(*q), c4 = cos(*q); q234 += *q; q++;
        double s5 = sin(*q), c5 = cos(*q); q++;
        double s6 = sin(*q), c6 = cos(*q);
        double s23 = sin(q23), c23 = cos(q23);
        double s234 = sin(q234), c234 = cos(q234);
    
        *T = c6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * s6; T++;  //nx
        *T = -s6 * (s1 * s5 + c234 * c1 * c5) - s234 * c1 * c6; T++;  //Ox
        *T = -(c234 * c1 * s5 - c5 * s1); T++;//ax
        *T = -(d6 * c234 * c1 * s5 - a3 * c23 * c1 - a2 * c1 * c2 - d6 * c5 * s1 - d5 * s234 * c1 - d4 * s1); T++;//Px
    
        *T = -c6 * (c1 * s5 - c234 * c5 * s1) - s234 * s1 * s6; T++;//ny
        *T = s6 * (c1 * s5 - c234 * c5 * s1) - s234 * c6 * s1; T++;//Oy
        *T = -(c1 * c5 + c234 * s1 * s5); T++;//ay
        *T = -(d6 * (c1 * c5 + c234 * s1 * s5) + d4 * c1 - a3 * c23 * s1 - a2 * c2 * s1 - d5 * s234 * s1); T++;//py
    
    
        *T = -(-c234 * s6 - s234 * c5 * c6); T++;//nz
        *T = -(s234 * c5 * s6 - c234 * c6); T++;//oz
        *T = -s234 * s5; T++;//az
        *T = d1 + a3 * s23 + a2 * s2 - d5 * (c23 * c4 - s23 * s4) - d6 * s5 * (c23 * s4 + s23 * c4); T++;//Pz
        *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
    }
    int inverse(const double* T, double* q_sols, double* q) {
        int num_sols = 0;
        double T00 = *T; T++; double T01 = *T; T++; double T02 = *T; T++; double T03 = *T; T++;
        double T10 = *T; T++; double T11 = *T; T++; double T12 = *T; T++; double T13 = *T; T++;
        double T20 = *T; T++; double T21 = *T; T++; double T22 = *T; T++; double T23 = *T;
        double qq1, qq2, qq3, qq4, qq5, qq6;
    
        // shoulder rotate joint (q1) //
        double q1[2];
        {
            double A = d6 * T12 - T13;
            double B = d6 * T02 - T03;
            double R = A * A + B * B;
            if (fabs(A) < ZERO_THRESH) {
                double div;
                if (fabs(fabs(d4) - fabs(B)) < ZERO_THRESH)
                    div = -SIGN(d4) * SIGN(B);
                else
                    div = -d4 / B;
                double arcsin = asin(div);
                if (fabs(arcsin) < ZERO_THRESH)
                    arcsin = 0.0;
                if (arcsin < 0.0)
                    q1[0] = arcsin + 2.0 * PI;
                else
                    q1[0] = arcsin;
                q1[1] = PI - arcsin;
            }
            else if (fabs(B) < ZERO_THRESH) {
                double div;
                if (fabs(fabs(d4) - fabs(A)) < ZERO_THRESH)
                    div = SIGN(d4) * SIGN(A);
                else
                    div = d4 / A;
                double arccos = acos(div);
                q1[0] = arccos;
                q1[1] = 2.0 * PI - arccos;
            }
            else if (d4 * d4 > R) {
                return num_sols;
            }
            else {
                double arccos = acos(d4 / sqrt(R));
                double arctan = atan2(-B, A);
                double pos = arccos + arctan;
                double neg = -arccos + arctan;
                if (fabs(pos) < ZERO_THRESH)
                    pos = 0.0;
                if (fabs(neg) < ZERO_THRESH)
                    neg = 0.0;
                if (pos >= 0.0)
                    q1[0] = pos;
                else
                    q1[0] = 2.0 * PI + pos;
                if (neg >= 0.0)
                    q1[1] = neg;
                else
                    q1[1] = 2.0 * PI + neg;
            }
    
            qq1 = q1[1];
        }
        
    
        // wrist 2 joint (q5) //
        double q5[2][2];
        {
            for (int i = 0; i < 2; i++) {
                double numer = (T03 * sin(q1[i]) - T13 * cos(q1[i]) - d4);
                double div;
                if (fabs(fabs(numer) - fabs(d6)) < ZERO_THRESH)
                    div = SIGN(numer) * SIGN(d6);
                else
                    div = numer / d6;
                double arccos = acos(div);
                q5[i][0] = arccos;
                q5[i][1] = 2.0 * PI - arccos;
            }
    
            qq5 = q5[1][0];
        }
        
    
        {
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 2; j++) {
                    double c1 = cos(q1[i]), s1 = sin(q1[i]);
                    double c5 = cos(q5[i][j]), s5 = sin(q5[i][j]);
                    double q6;
                    // wrist 3 joint (q6) //
                    if (fabs(s5) < ZERO_THRESH)
                        q6 = 0;
                    else {
                        q6 = atan2(SIGN(s5) * -(T01 * s1 - T11 * c1),
                            SIGN(s5) * (T00 * s1 - T10 * c1));
                        if (fabs(q6) < ZERO_THRESH)
                            q6 = 0.0;
                        if (q6 < 0.0)
                            q6 += 2.0 * PI;
                    }
                    
    
                    double q2[2], q3[2], q4[2];
                    / RRR joints (q2,q3,q4) 
                    double c6 = cos(q6), s6 = sin(q6);
                    double x04x = -s5 * (T02 * c1 + T12 * s1) - c5 * (s6 * (T01 * c1 + T11 * s1) - c6 * (T00 * c1 + T10 * s1));
                    double x04y = c5 * (T20 * c6 - T21 * s6) - T22 * s5;
                    double p13x = d5 * (s6 * (T00 * c1 + T10 * s1) + c6 * (T01 * c1 + T11 * s1)) - d6 * (T02 * c1 + T12 * s1) +
                        T03 * c1 + T13 * s1;
                    double p13y = T23 - d1 - d6 * T22 + d5 * (T21 * c6 + T20 * s6);
    
                    double c3 = (p13x * p13x + p13y * p13y - a2 * a2 - a3 * a3) / (2.0 * a2 * a3);
                    if (fabs(fabs(c3) - 1.0) < ZERO_THRESH)
                        c3 = SIGN(c3);
                    else if (fabs(c3) > 1.0) {
                        // TODO NO SOLUTION
                        continue;
                    }
                    double arccos = acos(c3);
                    q3[0] = arccos;
                    q3[1] = 2.0 * PI - arccos;
                    double denom = a2 * a2 + a3 * a3 + 2 * a2 * a3 * c3;
                    double s3 = sin(arccos);
                    double A = (a2 + a3 * c3), B = a3 * s3;
                    q2[0] = atan2((A * p13y - B * p13x) / denom, (A * p13x + B * p13y) / denom);
                    q2[1] = atan2((A * p13y + B * p13x) / denom, (A * p13x - B * p13y) / denom);
                    double c23_0 = cos(q2[0] + q3[0]);
                    double s23_0 = sin(q2[0] + q3[0]);
                    double c23_1 = cos(q2[1] + q3[1]);
                    double s23_1 = sin(q2[1] + q3[1]);
                    q4[0] = atan2(c23_0 * x04y - s23_0 * x04x, x04x * c23_0 + x04y * s23_0);
                    q4[1] = atan2(c23_1 * x04y - s23_1 * x04x, x04x * c23_1 + x04y * s23_1);
                    qq6 = q6;
                    qq2 = q2[0];
                    qq3 = q3[0];
                    qq4 = q4[0];
    
    
                    
                    for (int k = 0; k < 2; k++) {
                        if (fabs(q2[k]) < ZERO_THRESH)
                            q2[k] = 0.0;
                        else if (q2[k] < 0.0) q2[k] += 2.0 * PI;
                        if (fabs(q4[k]) < ZERO_THRESH)
                            q4[k] = 0.0;
                        else if (q4[k] < 0.0) q4[k] += 2.0 * PI;
                        q_sols[num_sols * 6 + 0] = q1[i];    q_sols[num_sols * 6 + 1] = q2[k];
                        q_sols[num_sols * 6 + 2] = q3[k];    q_sols[num_sols * 6 + 3] = q4[k];
                        q_sols[num_sols * 6 + 4] = q5[i][j]; q_sols[num_sols * 6 + 5] = q6;
    
    
    
                        num_sols++;
                    }
    
                }
            }
        }
        *q = qq1; q++; *q = qq2; q++; *q = qq3; q++; *q = qq4; q++; *q = qq5; q++; *q = qq6;
    
        return num_sols;
    }
    void OutputT(double t[4][4])
    
    {
        
        
        cout << "输出由q 进行正运动学结果T:   " << endl;
        for (int i = 0; i < 4; i++)
        {
            for (int j = 0; j < 4; j++)
            {
                cout << t[i][j] << "      ";
            }
            cout << endl;
        }
    }
    void OuputQuat(double quat[4])
    
    {
        cout << "四元数quat:" << " [  " << quat[0] << "   " << quat[1] << "   " << quat[2] << "   " << quat[3] << "  ] " << endl;
    
       
    }
    void OutputQ(double q[6])
    
    {
        cout << "关节角度q:" << " [  " << q[0] << "   " << q[1] << "   " << q[2] << "   " << q[3] <<  "   " << q[4] <<"   " << q[5] <<"  ] " << endl;
    
    
    }
    void Quat_to_Dcm(double quat[4], double* T)
    {
        double q0 = quat[0], q1 = quat[1],q2 = quat[2] ,q3 = quat[3];
        *T = q0*q0+q1*q1-q2*q2-q3*q3; T++;  //T00
        *T = 2*(q1*q2 - q0*q3); T++;  //T01
        *T = 2 * (q1 * q3 + q0 * q2); T++;//T02
        *T = 0; T++;//Px
    
        *T = 2 * (q1 * q2 +q0 * q3); T++;//ny  T10
        *T = q0 * q0 +-q1 * q1 + q2 * q2 - q3 * q3; T++;//Oy   T11
        *T = 2 * (q2 * q3 - q0 * q1); T++;//ay   T12
        *T = 0; T++;//py
    
    
        *T = 2 * (q1 * q3 - q0 * q2); T++;//nz  T20
        *T = 2 * (q3 * q2 + q0 * q1); T++;//oz   T21
        *T = q0 * q0 + -q1 * q1 - q2 * q2 +q3 * q3; T++;//az  T22
        *T = 0; T++;//Pz
        *T = 0.0; T++; *T = 0.0; T++; *T = 0.0; T++; *T = 1.0;//姿态
    }
    void Dcm_to_Quat(double T[4][4],double * Quat)
    {
        double q0, q1, q2, q3;
        q0 = 0.5 * sqrt(1 + T[0][0] + T[1][1] + T[2][2]);
        q1 = (T[2][1] - T[1][2]) / (4 * q0);
        q2 = (T[0][2] - T[2][0]) / (4 * q0);
        q3 = (T[1][0] - T[0][1]) / (4 * q0);
        *Quat = q0; Quat++;  *Quat = q1; Quat++;  *Quat=q2; Quat++; *Quat = q3;
    
    
    }
    void Ctraj(double T1[4][4], double T2[4][4], int t)
    {
        for (double i = 0; i <= t;i++)
        {
            double T_temp[4][4]; double* T_Temp = &T_temp[0][0];
            double q[6];// double* Q = &q[0];
            double s = i / t;
            
            //姿态部分
            double quat1[4], quat2[4], quat_temp[4];
            double* Quat1 = &quat1[0], * Quat2 = &quat2[0], * Quat_temp = &quat_temp[0];
            Dcm_to_Quat(T1, Quat1); Dcm_to_Quat(T2, Quat2);
            //quat   quat_temp = quat1 + s(quat2 - quat1)
            quat_temp[0] = quat1[0] + s * (quat2[0] - quat1[0]);
            quat_temp[1] = quat1[1] + s * (quat2[1] - quat1[1]);
            quat_temp[2] = quat1[2] + s * (quat2[2] - quat1[2]);
            quat_temp[3] = quat1[3] + s * (quat2[3] - quat1[3]);
            Quat_to_Dcm(quat_temp, T_Temp);
            
            //位置部分
            
            double p1[3], p2[3], p_temp[3];
            p1[0] = T1[0][3]; p1[1] = T1[1][3]; p1[2] = T1[2][3];
            p2[0] = T2[0][3]; p2[1] = T2[1][3]; p2[2] = T2[2][3];
            //p_temp = p1 + s(p2-p1)   s(0→1)(p1→p2)
            p_temp[0] = p1[0] + s * (p2[0] - p1[0]); p_temp[1] = p1[1] + s * (p2[1] - p1[1]); p_temp[2] = p1[2] + s * (p2[2] - p1[2]); 
            T_temp[0][3] = p_temp[0]; T_temp[1][3] = p_temp[1]; T_temp[2][3] = p_temp[2];
            double q_sols[48]; int num_sols;
            num_sols = inverse(T_Temp, q_sols, q);
            cout <<endl<<"i = "<< i << endl ;
            OutputT(T_temp); OutputQ(q);
        }
    }
    int main()
    
    {
        double qa[6] = { 0.1 ,0.2,0.3,0.4,0.5,0.6 }, qb[6] = { 0.7 ,0.8,0.9,1.0,1.1,1.2 };//q为关节角度
        double ta[4][4], tb[4][4];
        double* Qa = &qa[0], * Qb = &qb[0], * Ta = &ta[0][0], * Tb = &tb[0][0];
        forward(Qa, Ta); forward(Qb, Tb);
        cout << "初始矩阵Ta: " << endl;OutputT(ta); cout << "终止矩阵Tb: " << endl; OutputT(tb);    
        int t = 10;
        Ctraj(ta, tb, t);
        
    
    }
    

    我每次粘贴的代码都是完整代码,包含里边需要的函数,所以不要将我不同PART的代码放在一起·运行,会出bug
    运行结果

    初始矩阵Ta:
    输出由q 进行正运动学结果T:
    0.0473957      -0.976785      -0.208915      1.18382
    -0.392918      0.174058      -0.90295      -0.127305
    0.918351      0.124882      -0.375547      0.416715
    0      0      0      1
    终止矩阵Tb:
    输出由q 进行正运动学结果T:
    -0.210275      -0.361227      0.90846      0.496913
    -0.599338      0.781771      0.172127      0.149518
    -0.772385      -0.508281      -0.380884      1.20334
    0      0      0      1
    
    i = 0
    输出由q 进行正运动学结果T:
    0.0473957      -0.976785      -0.208915      1.18382
    -0.392918      0.174058      -0.90295      -0.127305
    0.918351      0.124882      -0.375547      0.416715
    0      0      0      1
    关节角度q: [  0.1   0.2   0.3   0.4   0.5   0.6  ]
    
    i = 1
    输出由q 进行正运动学结果T:
    0.141285      -0.705088      -0.18535      1.11513
    -0.190259      0.146597      -0.702692      -0.0996231
    0.703779      0.181178      -0.152755      0.495377
    0      0      0      1
    关节角度q: [  0.114481   0.25323   0.305191   -0.0345366   0.827227   0.834109  ]
    
    i = 2
    输出由q 进行正运动学结果T:
    0.208583      -0.480089      -0.142192      1.04644
    -0.0372217      0.138742      -0.523045      -0.0719408
    0.499318      0.210893      0.0204082      0.574039
    0      0      0      1
    关节角度q: [  0.132933   0.00588692   0.717431   2.32152   1.04768   4.40191  ]
    
    i = 3
    输出由q 进行正运动学结果T:
    0.249292      -0.301788      -0.079439      0.977747
    0.0661928      0.150496      -0.364009      -0.0442585
    0.304967      0.214028      0.143944      0.652701
    0      0      0      1
    关节角度q: [  0.156335   0.0162988   0.948902   1.35948   1.21621   4.84737  ]
    
    i = 4
    输出由q 进行正运动学结果T:
    0.26341      -0.170185      0.00290758      0.909056
    0.119985      0.181856      -0.225584      -0.0165762
    0.120728      0.190582      0.217852      0.731363
    0      0      0      1
    关节角度q: [  0.186033   0.102284   1.01767   0.627397   1.3467   5.0304  ]
    
    i = 5
    输出由q 进行正运动学结果T:
    0.250938      -0.0852805      0.104848      0.840366
    0.124154      0.232824      -0.107771      0.0111061
    -0.0534012      0.140556      0.242132      0.810025
    0      0      0      1
    关节角度q: [  0.223918   0.212333   1.02929   0.0164071   1.44208   4.97203  ]
    
    i = 6
    输出由q 进行正运动学结果T:
    0.211876      -0.0470737      0.226383      0.771675
    0.0787007      0.303399      -0.0105691      0.0387884
    -0.217419      0.0639497      0.216785      0.888687
    0      0      0      1
    关节角度q: [  0.272726   0.350961   0.984728   -0.54655   1.49958   4.77372  ]
    
    i = 7
    输出由q 进行正运动学结果T:
    0.146223      -0.0555649      0.367511      0.702984
    -0.0163752      0.393581      0.0660218      0.0664707
    -0.371327      -0.0392372      0.141809      0.967349
    0      0      0      1
    关节角度q: [  0.336517   0.526787   0.857911   -1.01752   1.51173   4.55033  ]
    
    i = 8
    输出由q 进行正运动学结果T:
    0.0539806      -0.110754      0.528233      0.634294
    -0.161074      0.50337      0.122001      0.094153
    -0.515124      -0.169005      0.0172059      1.04601
    0      0      0      1
    关节角度q: [  0.421512   0.757787   0.598733   -1.32418   1.4658   4.38912  ]
    
    i = 9
    输出由q 进行正运动学结果T:
    -0.0648523      -0.212641      0.70855      0.565603
    -0.355395      0.632767      0.15737      0.121835
    -0.648809      -0.325352      -0.157025      1.12467
    0      0      0      1
    关节角度q: [  0.537494   0.62214   1.00414   1.29131   1.3412   1.17569  ]
    
    i = 10
    输出由q 进行正运动学结果T:
    -0.210275      -0.361227      0.90846      0.496913
    -0.599338      0.781771      0.172127      0.149518
    -0.772385      -0.508281      -0.380884      1.20334
    0      0      0      1
    关节角度q: [  0.7   0.8   0.9   1   1.1   1.2  ]
    

    3.3matlab的仿真结果验证
    代码

    %%
    %标准DH参数表
    %通用格式L = Link([alpha A seita D seigema],CONVENTION)
    clc
    L1 = Link([0 0.1273 0 pi/2 0],'standard');
    L2 = Link([0 0 0.612 0 0],'standard');
    L3 = Link([0 0 0.5723 0 0],'standard');
    L4 = Link([0 0.163941 0 pi/2 0],'standard');
    L5 = Link([0 0.1157 0 -pi/2 0],'standard');
    L6 = Link([0 0.0922 0 0 0],'standard');
    ur10 = SerialLink([L1 L2 L3 L4 L5 L6]);
    qa = [0.1,0.2,0.3,0.4,0.5,0.6];
    qb = [0.7,0.8,0.9,1.0,1.1,1.2];
    Ta = ur10.fkine(qa);
    Tb = ur10.fkine(qb);
    t = 0:0.1:1;
    Ts = ctraj(Ta,Tb,length(t));
    for i = 1:11
        
         Ts(i)
         %q = ur10.ikine(Ts(i))
    end
    

    运行结果

    ans = 
        0.0474   -0.9768   -0.2089     1.184
       -0.3929    0.1741   -0.9030   -0.1273
        0.9184    0.1249   -0.3755    0.4167
             0         0         0         1
     
    
    ans = 
        0.1086   -0.9672   -0.2297     1.168
       -0.3345    0.1820   -0.9247   -0.1211
        0.9361    0.1772   -0.3037    0.4344
             0         0         0         1
     
    
    ans = 
        0.2951   -0.9187   -0.2626     1.122
       -0.1552    0.2251   -0.9619   -0.1024
        0.9428    0.3246   -0.0762    0.4875
             0         0         0         1
     
    
    ans = 
        0.5850   -0.7815   -0.2167     1.045
        0.1272    0.3524   -0.9272  -0.07125
        0.8010    0.5149    0.3056     0.576
             0         0         0         1
     
    
    ans = 
        0.8423   -0.5388    0.0139    0.9434
        0.3851    0.5836   -0.7150  -0.03042
        0.3771    0.6076    0.6990     0.692
             0         0         0         1
     
    
    ans = 
        0.8804   -0.2992    0.3679    0.8404
        0.4356    0.8169   -0.3781   0.01111
       -0.1874    0.4931    0.8495      0.81
             0         0         0         1
     
    
    ans = 
        0.6801   -0.1513    0.7174    0.7373
        0.2551    0.9662   -0.0381   0.05263
       -0.6873    0.2089    0.6957     0.928
             0         0         0         1
     
    
    ans = 
        0.3191   -0.1463    0.9364     0.636
       -0.0858    0.9795    0.1823   0.09346
       -0.9438   -0.1385    0.3000     1.044
             0         0         0         1
     
    
    ans = 
        0.0107   -0.2392    0.9709    0.5587
       -0.3831    0.8959    0.2249    0.1246
       -0.9237   -0.3743   -0.0821     1.133
             0         0         0         1
     
    
    ans = 
       -0.1591   -0.3276    0.9313    0.5124
       -0.5489    0.8134    0.1924    0.1433
       -0.8206   -0.4806   -0.3093     1.186
             0         0         0         1
     
    
    ans = 
       -0.2103   -0.3612    0.9085    0.4969
       -0.5993    0.7818    0.1721    0.1495
       -0.7724   -0.5083   -0.3809     1.203
             0         0         0         1
    

    matlab关于机器人的功能包可以看我资源分享有一个PPT,写的很是完整,来自学校老师的课程。

    matlab代码中有一行注释,就是我尝试算出q(i)然后打印,像我C++语言实现的一样,但是matlab自带的逆运动学求解代码不咋地,有的算不出来。

    4.总结

    本文实现了UR10机器人在笛卡尔空间下轨迹规划的C++代码编写,实现了线性插值,其中旋转矩阵插值使用四元数插值。
    该文章存在两个待解决的问题
    一个是我编写的笛卡尔轨迹规划代码输出是直接在函数出输出到srceen上,但是这样是不对的,应该用指针返回,对我有点难嘻嘻嘻~我明天会改!
    第二个是可以看出我输出的插值矩阵,和matlab输出的不一样,可能的原因我在上文提到过,是因为matlab用的应该不是线性插值,所以没办法确认旋转矩阵的四元数插值是百分百正正确,我尝试逆运动学输出去,看起来没有问题。我在下文会进行旋转矩阵的图形显示,来确保一下!

    展开全文
  • 从家到学校的详细地图这样画

    千次阅读 2020-12-21 15:19:32
    从家到学校的详细地图这样画先做前期准备工作。指导学生认识地图,老师用手比划着指导大家熟背口诀“上北下南,左西右东”,直到每个学生都能顺口溜出来。????????????????再准备一张地图,最好是学生都很熟悉的学校...
  • Android 百度鹰眼轨迹SDK(v2.1.6)

    万次阅读 2016-03-22 17:57:27
    效果图本篇为百度地图SDK第三篇博文第一篇实现:Android 百度地图周边雷达(v3.7.0)及覆盖物第二篇实现:Android 百度定位SDK(v3.7.0)结合方向传感器本博文为第三篇使用百度鹰眼轨迹SDK可以实现的功能 轨迹追踪 ...
  • 通过上述机制,我们的AVGCN在几个不同的轨迹预测基准中实现了最先进的性能,并在所有考虑的数据集中实现了最佳的平均性能 框架结构 整个轨道预测系统 为了清晰起见,我们仅展示了行人i的轨迹预测过程。该系统包含一...
  • 不过对于大学,很多人进入大学的时候,可能都是同一个起点,大学四年过后,却是完全不同的人生轨迹。正好我也想记录下自己从高中进入大学这几年的学习与变化,我的大学经历,可以说是非常普通,没有参加任何竞赛,也...
  • 此文档旨在解释说明学校人员定位管理系统的原理与构成、系统功能和相关案例。未经授权,不得以任何形式转载篡改,奔骝科技不对篡改后的文档负责。 1.2 读者对象 集成商销售 依据本解决方案,集成商销售可以...
  • Git学习轨迹

    2020-12-11 17:15:12
    落后生产工具 svn ...一般用于在企业、学校等内部网络搭建git私服 提供代码托管、提交审核和问题跟踪的代码管理平台 svn是集中化的版本控制系统 git是分布式的版本控制系统 git就是一种版本控制工具 ...
  • 使用百度地图API制作线路轨迹播放

    千次阅读 2020-12-19 10:34:36
    可应用于车辆跟踪、行驶线路回放、跑步行程的记录等地图应用场景,1.1绘制静态轨迹图获取多个轨迹点point(必须包含经度、纬度)使用polyline对象依次连接相邻的2个点(注意polyline的个数比point的少1)1.2绘制动态轨迹...
  • 距离上次写博客大概有半年了,这次博客是补半年前做过的项目的一部分,给小车... } } 三、结语 疫情在家令人懒惰了大半年,来到学校后,身边优秀的人确实给了我很大的压力和动力,喜欢编程就要把这个东西一直做下去。
  • 轨迹

    2015-10-18 22:26:32
    轨迹2013年我大学入学,学的是电子信息工程专业。从电子转为软件,也算另类吧。 谨以此博文,记录我与编程的点点滴滴, * 这个我可能一辈子都离不开的东西。*2013.9.1 大学入学 | |---大一下学期,学校开设了...
  •   前面我们博客中写到过用谷歌地图来绘制移动轨迹,但该方法存在一定的局限性:一是谷歌地图没有具体的建筑物轮廓;二是谷歌地图通常需要插件或者外网才能...  首先来一张效果展示图,加入我打算绕学校跑一圈,...
  • 后来我一寻思,换完电脑要是还崩,我估计秋收的活也是我干了(本蓝这两天在种地,学校不开学让我成了一个快乐的农村娃)。于是我听取了我同学小可条的建议,采用分批处理。 话说回来,也怪我图省事,本来人家按照每...
  • 五一长假,外面的世界人山人海,自己在家里想捋一捋近几年的成长轨迹图,供学弟学妹们参考。 2014.6--2015.7:入门 这是毕业后迷茫的2年,但也是成长最快的两年。从软件测试外行逐渐入门,至少这2年里,有半只脚是...
  • 编辑校园范围 处理学校坐标范围并初始化地图 自定义工具栏以及渲染学校范围 编辑学校范围并获取,更新到数据 3.3:在线地图上显示某个经纬度 自定义图标以及在地图上显示 3.4 查询设备轨迹(添加箭头,动画效果,起...
  • 单个标注点沿直线的轨迹运动 <div id="allmap"></div> <!-- <div id = "content"></div>--> // 百度地图API功能 var map = new BMap.Map("allmap"); //创建Map实例 //初始化 调用centerAndZoom方法对...
  • 东方网记者刘轶琳4月16日报道:上海有近百所国际学校,上海国际学校数量排全国之首,但国际教育并不适合每一个学生。在本周末举行的一场家长俱乐部活动上,教育专家提醒,国际学校对学生的体育、艺术素养要求更高,...
  • 如果只上一所学校的课,那么显然要选择这所学校的所有课程。因此,至少有一所学校选择的课程权值超过了这所学校总权值的一半。不妨强制第一所学校要超过,那么设第一所学校第一次前缀和超过总权值一半的位置为ppp,...
  • 走进许昌科技学校

    2020-12-22 19:19:54
    许昌科技学校(许昌市第五高级中学)建于1958年,是许昌市教育局直属公办全日制学校,是首批国家级重点中专、河南省职教特色学校、许昌市职教名校。2018年9月,学校整体搬迁至许昌市职教园区新校区,现占地面积300余亩,...
  • 百度地图API使用第一弹 ——动态轨迹运动封装 你还在为冗杂的百度地图API看着看着就想睡觉而犯愁吗? 你还在不会使用百度地图生成动态轨迹而犯愁吗? 你还在为百度地图默认的路线不符合自己的轨迹而犯愁吗? ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,843
精华内容 3,937
关键字:

学校轨迹