NMEA数据转Google Earth的KML工具

最新推荐文章于 2024-05-07 13:39:37 发布

伊伊_f

最新推荐文章于 2024-05-07 13:39:37 发布

阅读量1.5k

点赞数

分类专栏： GNSS

原文链接：https://blog.csdn.net/hit1524468/article/details/79749707

版权

GNSS 专栏收录该内容

14 篇文章 4 订阅

订阅专栏

1. 背景

在关于GPS定位的研究分析过程中，经常想要看在一段测试路径上，GPS的定位准确性如何，实际上，很自然的会想到把GPS数据显示在地图上，然而，并且，Google提供的Google Earth就是一个不错的工具，至于为什么不选择别的地图工具，是因为别的地图需要进行WGS84坐标系进行转换。

2. 实现代码

2.1 NMEA格式数据转化为KML的头文件

#ifndef CONVERT_H
#define CONVERT_H
#include <iostream>
#include <string>
#include <vector>
#include <fstream>
#include <memory.h>
#include <math.h>
#include <sstream>
#include <string.h>
using namespace std;
// 模块名称： convert
// Author: HSW
// Date： 2018-01-17
// 功能: 实现NMEA GGA数据分析
//
//
// NMEA GGA 数据分析
int splitString1(string lineBuf, vector<string>& subStrs, char dim = ',');
// ddmm.mmmm <==> dd.dddd
int fromDMToDegree(double ddmmPointMMMM, double& ddPointDDDD);
int fromDegreeToDM(double ddPointDDDD, double& ddmmPointMMMM);
// KML: 保存为KML文件
// strs: 分别包含：描述
// 名称
// 经度
// 纬度
// 高度
int convertToKMLWithoutName(vector<string>& pointInfo, ofstream* pOfstr, int Mode);
#endif // CONVERT_H

#include "convert.h"
#include <windows.h>
#include <ctmstrconvert.h>
static wstring kml_S = L"<kml xmlns=\"http://earth.google.com/kml/2.0\">\r\n";
static wstring kmlFolder_S = L"<Folder>\r\n";
static wstring kmlPlacemark_S = L"<Placemark>";
static wstring kmlDescription_S = L"<description>";
static wstring kmlDescription_E = L"</description>";
static wstring kmlName_S = L"<name>";
static wstring kmlName_E = L"</name>";
static wstring kmlLookat_S = L"<LookAt>";
static wstring kmlLon_S = L"<longitude>";
static wstring kmlLon_E = L"</longitude>";
static wstring kmlLat_S = L"<latitude>";
static wstring kmlLat_E = L"</latitude>";
static wstring kmlRange_S = L"<range>";
static wstring kmlRange_E = L"</range>";
static wstring kmlTilt_S = L"<tilt>";
static wstring kmlTilt_E = L"</tilt>";
static wstring kmlHeading_S = L"<heading>";
static wstring kmlHeading_E = L"</heading>";
static wstring kmlLookat_E = L"</LookAt>";
static wstring kmlPoint_S = L"<Point>";
static wstring kmlCoordinates_S = L"<coordinates>";
static wstring kmlCoordinates_E = L"</coordinates>";
static wstring kmlPoint_E = L"</Point>";
static wstring kmlPlacemark_E = L"</Placemark>\r\n";
static wstring kmlFolder_E = L"</Folder>\r\n";
static wstring kml_E = L"</kml>\r\n";
static wstring kml_default_range = L"20000";
static wstring kml_default_tilt = L"0";
static wstring kml_default_heading = L"3";
static string kml_default_altitude = "0";
static wstring kml_default_pointSetName = L"Positions";
// 实现差分前后的数据处理
//
static char exampleGGA[4][128] = {"$GPGGA,062926.000,4538.7429,N,12639.4155,E,2,08,1.0,196.6,M,0.0,M,23,1544*6C",
"$GPGGA,062926.000,4538.7429,N,12639.4155,W,2,08,1.0,196.6,M,0.0,M,23,1544*6C",
"$GPGGA,062926.000,4538.7429,S,12639.4155,E,2,08,1.0,196.6,M,0.0,M,23,1544*6C",
"$GPGGA,062926.000,4538.7429,N,12639.4155,W,2,08,1.0,196.6,M,0.0,M,23,1544*6C"};
// 将std::string 转为利用UTF-8编码的std::string
// step1: 将std::string 转为 std::wstring
// 方法1：
BOOL StringToWString(const std::string &str,std::wstring &wstr)
{
int nLen = (int)str.length();
wstr.resize(nLen,L' ');
int nResult = MultiByteToWideChar(CP_ACP,0,(LPCSTR)str.c_str(),nLen,(LPWSTR)wstr.c_str(),nLen);
if (nResult == 0)
{
return FALSE;
}
return TRUE;
}
//wstring高字节不为0，返回FALSE
BOOL WStringToString(const std::wstring &wstr,std::string &str)
{
int nLen = (int)wstr.length();
str.resize(nLen,' ');
int nResult = WideCharToMultiByte(CP_ACP,0,(LPCWSTR)wstr.c_str(),nLen,(LPSTR)str.c_str(),nLen,NULL,NULL);
if (nResult == 0)
{
return FALSE;
}
return TRUE;
}
std::string to_utf8(const wchar_t* buffer, int len)
{
int nChars = ::WideCharToMultiByte(
CP_UTF8,
0,
buffer,
len,
NULL,
0,
NULL,
NULL);
if (nChars == 0) return "";
string newbuffer;
newbuffer.resize(nChars) ;
::WideCharToMultiByte(
CP_UTF8,
0,
buffer,
len,
const_cast< char* >(newbuffer.c_str()),
nChars,
NULL,
NULL);
return newbuffer;
}
// std::string 转为 std::string UTF-8
std::string to_utf8(const std::wstring& str)
{
return to_utf8(str.c_str(), (int)str.size());
}
// NMEA GGA 数据分析
int splitString1(string lineBuf, vector<string>& subStrs, char dim)
{
size_t startPos = lineBuf.find('$');
size_t endPos = lineBuf.find('*');
int iter;
int count = 0;
char subStr[64] = {0};
int findGGA = 0;
if(startPos != string::npos && endPos != string::npos)
{
for(iter = startPos + 1; iter < endPos; ++iter)
{
char ch = lineBuf.at(iter);
if(ch == dim)
{
string tmp = string(subStr);
if(tmp.find("GGA") != string::npos)
{
findGGA = 1;
}
subStrs.push_back(string(subStr));
memset(subStr,0, sizeof(subStr));
count = 0;
}
else
{
subStr[count] = lineBuf.at(iter);
count++;
}
}
subStrs.push_back(string(subStr));
}
if(findGGA)
{
return 0;
}
else
{
return -1;
}
}
// DD.DDDD ==> ddmm.mmmm
int fromDegreeToDM(double ddPointDDDD, double& ddmmPointMMMM)
{
int tmpInt = (int)floor(ddPointDDDD);
double tmpFloat = ddPointDDDD - tmpInt;
ddmmPointMMMM = tmpInt * 100 + tmpFloat * 60;
return 0;
}
// ddmm.mmmm ==> DD.DDDD
int fromDMToDegree(double ddmmPointMMMM, double& ddPointDDDD)
{
int tmpInt = floor(ddmmPointMMMM / 100);
double tmpFloat = ddmmPointMMMM - tmpInt * 100;
ddPointDDDD = tmpInt + tmpFloat / 60;
return 0;
}
// nmea 计算检查和
unsigned char checkSum(const char* buf)
{
int isStart = 0;
int iter = 0;
unsigned char checksum = 0;
while(1)
{
if((unsigned char)buf[iter] == '$')
{
isStart = 1;
++iter;
continue;
}
if(isStart)
{
if((unsigned char)buf[iter] == '*')
{
break;
}
checksum ^= buf[iter];
}
++iter;
}
// cout << "checksum = " << checksum << endl;
return checksum;
}
// KML: 保存为KML文件, 不包含点的名称
// strs: 分别包含：描述
// 经度
// 纬度
// 注意：坐标点的高度默认设置为0
int convertToKMLWithoutName(vector<string>& pointInfo, ofstream* pOfstr, int Mode)
{
wstring utf8wStr = L""; // 宽字符
string utf8Str = ""; // UTF-8字符串
if(Mode == 0)
{
utf8Str = to_utf8(kml_S);
// pOfstr->write(kml_S.c_str(), kml_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kmlFolder_S);
// pOfstr->write(kmlFolder_S.c_str(), kmlFolder_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// 名称: kml文件的名称
utf8Str = to_utf8(kmlName_S);
//pOfstr->write(kmlName_S.c_str(), kmlName_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
StringToWString(pointInfo[0], utf8wStr);
utf8Str = to_utf8(utf8wStr);
//pOfstr->write(pointInfo[0].c_str(), pointInfo[0].length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlName_E);
// pOfstr->write(kmlName_E.c_str(), kmlName_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// 点集合名称: kml
// 点集合名称: kml
string outputPath = pointInfo[0];
size_t pos = outputPath.find_last_of('/');
if(pos != string::npos)
{
utf8Str = to_utf8(kmlName_S);
//pOfstr->write(kmlName_S.c_str(), kmlName_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// utf8Str = to_utf8(kml_default_pointSetName);
//pOfstr->write(kml_default_pointSetName.c_str(), kml_default_pointSetName.length());
CTMStrConvert converter;
wstring wPointsetName = converter.StringToWString(outputPath.substr(pos + 1, outputPath.length() - pos -1));
utf8Str = converter.WStringToUtf8(wPointsetName);
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlName_E);
// pOfstr->write(kmlName_E.c_str(), kmlName_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
}
else
{
utf8Str = to_utf8(kmlName_S);
//pOfstr->write(kmlName_S.c_str(), kmlName_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kml_default_pointSetName);
//pOfstr->write(kml_default_pointSetName.c_str(), kml_default_pointSetName.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlName_E);
// pOfstr->write(kmlName_E.c_str(), kmlName_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
}
wstring lineBuf = L"\r\n";
utf8Str = to_utf8(lineBuf);
// pOfstr->write(lineBuf.c_str(), lineBuf.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
}
else if(Mode == 1)
{
// Placemark
utf8Str = to_utf8(kmlPlacemark_S);
// pOfstr->write(kmlPlacemark_S.c_str(), kmlPlacemark_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// -描述
utf8Str = to_utf8(kmlDescription_S);
// pOfstr->write(kmlDescription_S.c_str(), kmlDescription_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
StringToWString(pointInfo[0], utf8wStr);
utf8Str = to_utf8(utf8wStr);
// pOfstr->write(pointInfo[0].c_str(), pointInfo[0].length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlDescription_E);
// pOfstr->write(kmlDescription_E.c_str(), kmlDescription_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
#if 0
// -名称
utf8Str = to_utf8(kmlName_S);
//pOfstr->write(kmlName_S.c_str(), kmlName_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
StringToWString(pointInfo[1], utf8wStr);
utf8Str = to_utf8(utf8wStr);
// pOfstr->write(pointInfo[1].c_str(), pointInfo[1].length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlName_E);
// pOfstr->write(kmlName_E.c_str(), kmlName_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
#endif
// -LookAt
utf8Str = to_utf8(kmlLookat_S);
// pOfstr->write(kmlLookat_S.c_str(), kmlLookat_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --lon 经度
utf8Str = to_utf8(kmlLon_S);
// pOfstr->write(kmlLon_S.c_str(), kmlLon_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
StringToWString(pointInfo[1], utf8wStr);
utf8Str = to_utf8(utf8wStr);
// pOfstr->write(pointInfo[2].c_str(), pointInfo[2].length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlLon_E);
// pOfstr->write(kmlLon_E.c_str(), kmlLon_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --lat 纬度
utf8Str = to_utf8(kmlLat_S);
// pOfstr->write(kmlLat_S.c_str(), kmlLat_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
StringToWString(pointInfo[2], utf8wStr);
utf8Str = to_utf8(utf8wStr);
// pOfstr->write(pointInfo[3].c_str(), pointInfo[3].length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlLat_E);
// pOfstr->write(kmlLat_E.c_str(), kmlLat_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --range
utf8Str = to_utf8(kmlRange_S);
// pOfstr->write(kmlRange_S.c_str(), kmlRange_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kml_default_range);
// pOfstr->write(kml_default_range.c_str(), kml_default_range.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlRange_E);
// pOfstr->write(kmlRange_E.c_str(), kmlRange_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --tilt
utf8Str = to_utf8(kmlTilt_S);
// pOfstr->write(kmlTilt_S.c_str(), kmlTilt_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kml_default_tilt);
// pOfstr->write(kml_default_tilt.c_str(), kml_default_tilt.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlTilt_E);
// pOfstr->write(kmlTilt_E.c_str(), kmlTilt_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --heading
utf8Str = to_utf8(kmlHeading_S);
// pOfstr->write(kmlHeading_S.c_str(), kmlHeading_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kml_default_heading);
// pOfstr->write(kml_default_heading.c_str(), kml_default_heading.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
utf8Str = to_utf8(kmlHeading_E);
// pOfstr->write(kmlHeading_E.c_str(), kmlHeading_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// -LookAt
utf8Str = to_utf8(kmlLookat_E);
// pOfstr->write(kmlLookat_E.c_str(), kmlLookat_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// -Point
utf8Str = to_utf8(kmlPoint_S);
// pOfstr->write(kmlPoint_S.c_str(), kmlPoint_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// --coordinate
utf8Str = to_utf8(kmlCoordinates_S);
// pOfstr->write(kmlCoordinates_S.c_str(), kmlCoordinates_S.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
string coordinate = pointInfo[1] + "," + pointInfo[2] + "," + kml_default_altitude;
StringToWString(coordinate, utf8wStr);
utf8Str = to_utf8(utf8wStr);
// pOfstr->write(coordinate.c_str(), coordinate.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8wStr.clear();
// --coordinate
utf8Str = to_utf8(kmlCoordinates_E);
// pOfstr->write(kmlCoordinates_E.c_str(), kmlCoordinates_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// -Point
utf8Str = to_utf8(kmlPoint_E);
// pOfstr->write(kmlPoint_E.c_str(), kmlPoint_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
// Placemark
utf8Str = to_utf8(kmlPlacemark_E);
// pOfstr->write(kmlPlacemark_E.c_str(), kmlPlacemark_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
}
else if(Mode == 2)
{
utf8Str = to_utf8(kmlFolder_E);
// pOfstr->write(kmlFolder_E.c_str(), kmlFolder_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
utf8Str = to_utf8(kml_E);
// pOfstr->write(kml_E.c_str(), kml_E.length());
pOfstr->write(utf8Str.c_str(), utf8Str.length());
utf8Str.clear();
}
pOfstr->flush();
return 0;
}

2.2 ASCII字符集和UTF-8字符集转换类

#ifndef CTMSTRCONVERT_H
#define CTMSTRCONVERT_H
#include <windows.h>
#include <iostream>
#include <string>
#include <wchar.h>
using namespace std;
// 模块名称：windows中字符串转换类
// Author: HSW
// Date: 2018-01-30
// 功能：实现多字节字符串与宽字节字符串之间的转换
// 多字节集合： ASCII / UTF8 等，一般情况下，ASCII为常用的字符串；UTF8主要在网页
// 宽字节集合: 表示汉字等需要使用宽字节
class CTMStrConvert
{
public:
CTMStrConvert();
~CTMStrConvert();
public:
wstring StringToWString(const char* abuffer, const int nLen);
wstring StringToWString(const string &astr);
wstring Utf8ToWString(const char* ubuffer, int nLen);
wstring Utf8ToWString(const string ustr);
string WStringToString(const wchar_t* wbuffer, const int nLen);
string WStringToString(const wstring &wstr);
string WStringToUtf8(const wchar_t* wbuffer, int nLen);
string WStringToUtf8(const wstring& wstr);
string StringToUtf8(const string &astr);
string StringToUtf8(const char* abuffer, const int nLen);
string Utf8ToString(const string ustr);
string Utf8ToString(const char* ubuffer, const int nLen);
};
#endif // CTMSTRCONVERT_H

#include "ctmstrconvert.h"
CTMStrConvert::CTMStrConvert()
{
}
CTMStrConvert::~CTMStrConvert()
{
}
// 功能：多字节(ASCII)字符串转宽字节字符串
// aBuffer: ASCII的多字节字符数组
// nLen: ASCII的多字节数组长度
// 返回：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
wstring CTMStrConvert::StringToWString(const char* abuffer, const int nLen)
{
// 需要的缓冲区大小
int nResult = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)abuffer, nLen, NULL, 0);
if (nResult == 0)
{
cout << "Get Wide Char Buffer Size Failed " << endl;
return L"";
}
wstring wstr;
wstr.resize(nResult, L' ');
nResult = MultiByteToWideChar(CP_ACP, 0, (LPCSTR)abuffer, nLen, (LPWSTR)wstr.c_str(), nResult);
if(nResult == 0)
{
cout << "From MultiByte To Wide Char Translate Failed " << endl;
return L"";
}
else
{
return wstr;
}
}
// 功能：多字节(ASCII)字符串转宽字节字符串
// astr: ASCII的多字节字符串
// 返回：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
wstring CTMStrConvert::StringToWString(const string &astr)
{
return StringToWString(astr.c_str(), astr.length());
}
// 功能：宽字节字符数组转为多字节(ASCII)字符串
// wbuffer: ASCII的多字节字符串
// len: 宽字节字符串
// 返回：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
string CTMStrConvert::WStringToString(const wchar_t* wbuffer, const int nLen)
{
// 获取需要的缓冲区的大小
int nResult = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wbuffer, nLen, NULL, 0, NULL, NULL);
if (nResult == 0)
{
cout << "Get Multi Byte Buffer Size Failed " << endl;
return "";
}
string astr;
astr.resize(nResult, ' ');
nResult = WideCharToMultiByte(CP_ACP, 0, (LPCWSTR)wbuffer, nLen, (LPSTR)astr.c_str(), nResult, NULL, NULL);
if (nResult == 0)
{
cout << "From Wide Char To Multi Byte Translate Failed " << endl;
return "";
}
else
{
return astr;
}
}
// 功能：宽字节字符串转为多字节(ASCII)字符串
// wstr: 宽字节字符串
// 返回：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
string CTMStrConvert::WStringToString(const wstring &wstr)
{
return WStringToString(wstr.c_str(), wstr.length());
}
// 功能：宽字节字符数组转为UTF-8多字节字符串
// wbuffer: 宽字节字符数组
// nLen: 宽字节字符数组的长度
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
string CTMStrConvert::WStringToUtf8(const wchar_t* wbuffer, int nLen)
{
// 获取所需的缓冲区大小
int nResult = WideCharToMultiByte(CP_UTF8, 0, wbuffer, nLen, NULL, 0, NULL, NULL);
if (nResult == 0)
{
cout << "Get Multi Byte Buffer Size Failed " << endl;
return "";
}
string ustr;
ustr.resize(nResult, ' ');
nResult = WideCharToMultiByte(CP_UTF8, 0, wbuffer, nLen, const_cast< char* >(ustr.c_str()), nResult, NULL, NULL);
if(nResult == 0)
{
cout << "Wide Char To Multi Byte Translate Failed " << endl;
return "";
}
else
{
return ustr;
}
}
// 功能：宽字节字符串转为 UTF-8
// wstr: 宽字节字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
string CTMStrConvert::WStringToUtf8(const wstring& wstr)
{
return WStringToUtf8(wstr.c_str(), (int)wstr.size());
}
// 功能: UTF-8多字节数组转为宽字节字符串
// ubuffer: UTF-8多字节数组
// len: UTF-8多字节数组长度
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
//
wstring CTMStrConvert::Utf8ToWString(const char* ubuffer, int nLen)
{
// 需要的缓冲区大小
int nResult = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ubuffer, nLen, NULL, 0);
if (nResult == 0)
{
cout << "Get Wide Char Buffer Size Failed " << endl;
return L"";
}
wstring wstr;
wstr.resize(nResult, L' ');
nResult = MultiByteToWideChar(CP_UTF8, 0, (LPCSTR)ubuffer, nLen, (LPWSTR)wstr.c_str(), nResult);
if(nResult == 0)
{
cout << "From MultiByte To Wide Char Translate Failed " << endl;
return L"";
}
else
{
return wstr;
}
}
// 功能: UTF-8多字节字符串转为宽字节字符串
// ustr: UTF-8多字节字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-01-30
// 修改记录：
wstring CTMStrConvert::Utf8ToWString(const string ustr)
{
return Utf8ToWString(ustr.c_str(), ustr.length());
}
// 功能：多字节(ASCII)字符串转为 UTF-8多字节字符串
// astr: 多字节(ASCII)字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-03-29
// 修改记录：
string CTMStrConvert::StringToUtf8(const string &astr)
{
wstring wstr = StringToWString(astr);
return WStringToUtf8(wstr);
}
// 功能：多字节(ASCII)字符串转为 UTF-8多字节字符串
// abuffer: 多字节(ASCII)字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-03-29
// 修改记录：
string CTMStrConvert::StringToUtf8(const char* abuffer, const int nLen)
{
wstring wstr = StringToWString(abuffer, nLen);
return WStringToUtf8(wstr);
}
// 功能： UTF-8多字节字符串转为多字节(ASCII)字符串
// ustr: UTF-8多字节字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-03-29
// 修改记录：
string CTMStrConvert::Utf8ToString(const string ustr)
{
wstring wstr = Utf8ToWString(ustr);
return WStringToString(wstr);
}
// 功能： UTF-8多字节字符串转为多字节(ASCII)字符串
// ubuffer: UTF-8多字节字符串
// 返回值：成功返回包含内容的字符串，失败返回空串
// 日期: 2018-03-29
// 修改记录：
string CTMStrConvert::Utf8ToString(const char* ubuffer, const int nLen)
{
wstring wstr = Utf8ToWString(ubuffer, nLen);
return WStringToString(wstr);
}

2.3 QT界面类

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <iostream>
#include <vector>
#include <string>
using namespace std;
namespace Ui {
class MainWindow;
}
typedef struct st_Support_Format
{
unsigned int supportTXT;
unsigned int supportCSV;
unsigned int supportRDF;
}st_Support_Format;
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
private:
void initialWindows();
int getFilePaths();
private slots:
void auto_slot();
void split_slot();
void batch_slot();
void support_txt_slot();
void support_csv_slot();
void openfile_slot();
void nmea_slot();
private:
Ui::MainWindow* ui;
unsigned int m_isAuto; // 是否通过Google自动打开
unsigned int m_isSplit; // 是否对每个KML文件分开显示
unsigned int m_isBatch; // 是否批处理
string m_googleEarthPath; // google Earth 的路径
string m_firstPath; // 选择的文件路径
string m_guiFirstPath; // 用于在GUI显示选择的文件路径
vector<string> m_filePaths; // 文件路径
st_Support_Format m_supportFormat; // 支持的文件格式
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "convert.h"
#include "ctmstrconvert.h"
#include <QFileDialog>
#include <QDir>
#include <QFile>
#include <QTextCodec>
#include <QMessageBox>
#include <QSettings>
#include <QDebug>
#include <windows.h>
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
// 初始化windows
initialWindows();
// Connect <===> Slot
connect(ui->autoCheckBox, SIGNAL(clicked(bool)), this, SLOT(auto_slot()));
connect(ui->splitCheckBox, SIGNAL(clicked(bool)), this, SLOT(split_slot()));
connect(ui->batchCheckBox, SIGNAL(clicked(bool)), this, SLOT(batch_slot()));
connect(ui->txtCheckBox, SIGNAL(clicked(bool)), this, SLOT(support_txt_slot()));
connect(ui->csvCheckBox, SIGNAL(clicked(bool)), this, SLOT(support_csv_slot()));
connect(ui->openFilePushButton, SIGNAL(clicked(bool)), this, SLOT(openfile_slot()));
connect(ui->convertNMEAPushButton, SIGNAL(clicked(bool)), this, SLOT(nmea_slot()));
// 设置support Push Button 的边框
ui->supportPushButton->setEnabled(false);
ui->supportPushButton->setStyleSheet("border: none");
}
MainWindow::~MainWindow()
{
delete ui;
}
void MainWindow::initialWindows()
{
if(ui->autoCheckBox->isChecked())
{
m_isAuto = 1;
ui->splitCheckBox->setEnabled(true);
}
else
{
m_isAuto = 0;
ui->splitCheckBox->setEnabled(false);
}
if(ui->splitCheckBox->isChecked())
{
m_isSplit = 1;
}
else
{
m_isSplit = 0;
}
if(ui->batchCheckBox->isChecked())
{
m_isBatch = 1;
ui->txtCheckBox->setEnabled(true);
ui->csvCheckBox->setEnabled(true);
}
else
{
m_isBatch = 0;
ui->txtCheckBox->setEnabled(false);
ui->csvCheckBox->setEnabled(false);
}
m_firstPath = ""; // 初始化为空
m_filePaths.clear();
QPixmap imagePix;
imagePix.load("gpsImage.jpg"); // 加载
ui->tmLabel->setScaledContents(true); // 设置自适应
ui->tmLabel->clear(); // 清空
ui->tmLabel->setPixmap(imagePix); // 加载到Label标签
ui->tmLabel->show(); // 显示
}
void MainWindow::auto_slot()
{
if(ui->autoCheckBox->isChecked())
{
m_isAuto = 1;
ui->splitCheckBox->setEnabled(true);
// Check Google Earth
QSettings *configIniRead = new QSettings("TM_Google_Earth.ini", QSettings::IniFormat);
QString googleEarthPath = configIniRead->value("/Path/googleEarthPath").toString();
// qDebug() << googleEarthPath;
if(googleEarthPath.isEmpty())
{
// 释放文件
configIniRead->deleteLater();
// 弹出选择google Earth 的路径
QMessageBox Msg(QMessageBox::Question,
QString(tr("配置GoogleEarth")),
QString(tr("选择GoogleEarth路径(例如：C:\\Program Files (x86)\\Google\\Google Earth\\client\\googleearth.exe)")));
QAbstractButton *pYesBtn = (QAbstractButton *)Msg.addButton(QString(tr("是")), QMessageBox::YesRole);
QAbstractButton *pNoBtn = (QAbstractButton *)Msg.addButton(QString(tr("否")), QMessageBox::NoRole);
Msg.exec();
if (Msg.clickedButton() != pYesBtn)
{
m_isAuto = 0;
ui->autoCheckBox->setChecked(false);
ui->splitCheckBox->setEnabled(false);
return ;
}
// 文件选择对话框：选择Google Earth 路径
QString qFilePath = QFileDialog::getOpenFileName(this, QString(tr("选择GoogleEarth路径")), "", "File(*.exe)", NULL);
if(!qFilePath.isEmpty())
{
m_googleEarthPath = qFilePath.toStdString();
QSettings *configIniWrite = new QSettings("TM_Google_Earth.ini", QSettings::IniFormat);
//向ini文件中写入内容,setValue函数的两个参数是键值对
configIniWrite->setValue("/Path/googleEarthPath", qFilePath);
configIniWrite->deleteLater();
}
else
{
QMessageBox Msg(QMessageBox::Question,
QString(tr("配置GoogleEarth")),
QString(tr("设置Google Earth 路径失败！")));
Msg.exec();
m_isAuto = 0;
ui->splitCheckBox->setEnabled(false);
}
}
else
{
m_googleEarthPath = googleEarthPath.toStdString();
configIniRead->deleteLater();
}
}
else
{
m_isAuto = 0;
ui->splitCheckBox->setEnabled(false);
}// if ... else ... isChecked()
}
void MainWindow::split_slot()
{
if(ui->splitCheckBox->isChecked())
{
m_isSplit = 1;
}
else
{
m_isSplit = 0;
}
}
void MainWindow::batch_slot()
{
if(ui->batchCheckBox->isChecked())
{
m_isBatch = 1;
ui->txtCheckBox->setEnabled(true);
ui->csvCheckBox->setEnabled(true);
}
else
{
m_isBatch = 0;
ui->txtCheckBox->setChecked(false);
ui->csvCheckBox->setChecked(false);
ui->txtCheckBox->setEnabled(false);
ui->csvCheckBox->setEnabled(false);
}
if(!ui->txtCheckBox->isChecked()
&& !ui->csvCheckBox->isChecked())
{
ui->convertNMEAPushButton->setEnabled(true);
}
}
void MainWindow::support_txt_slot()
{
if(ui->txtCheckBox->isChecked())
{
m_supportFormat.supportTXT = 1;
ui->convertNMEAPushButton->setEnabled(true);
}
else
{
m_supportFormat.supportTXT = 0;
if(!ui->txtCheckBox->isChecked()
&& !ui->csvCheckBox->isChecked())
{
ui->convertNMEAPushButton->setEnabled(true);
}
else if(!ui->csvCheckBox->isChecked())
{
ui->convertNMEAPushButton->setEnabled(false);
}
}
}
void MainWindow::support_csv_slot()
{
if(ui->csvCheckBox->isChecked())
{
m_supportFormat.supportCSV = 1;
ui->convertNMEAPushButton->setEnabled(true);
}
else
{
m_supportFormat.supportCSV = 0;
if(!ui->txtCheckBox->isChecked()
&& !ui->csvCheckBox->isChecked())
{
ui->convertNMEAPushButton->setEnabled(true);
}
else if(!ui->txtCheckBox->isChecked())
{
ui->convertNMEAPushButton->setEnabled(false);
}
}
}
void MainWindow::openfile_slot()
{
if(m_isBatch)
{// 批量处理
QString qFileDir = QFileDialog::getExistingDirectory(this, QString(tr("选择文件夹")), "");
if(!qFileDir.isEmpty())
{
QTextCodec *codec =QTextCodec::codecForName("UTF-8");
QString str = codec->toUnicode(qFileDir.toStdString().c_str());
wstring fileName = str.toStdWString();
CTMStrConvert converter;
m_firstPath = converter.WStringToString(fileName);
m_guiFirstPath = qFileDir.toStdString();
}
else
{
m_firstPath = "";
m_guiFirstPath = "";
}
}
else
{// 处理单个文件
QString qFilePath = QFileDialog::getOpenFileName(this, QString(tr("选择文件")), "", "File(*.txt *.csv)", NULL);
if(!qFilePath.isEmpty())
{
QTextCodec *codec =QTextCodec::codecForName("UTF-8");
QString str = codec->toUnicode(qFilePath.toStdString().c_str());
wstring fileName = str.toStdWString();
CTMStrConvert converter;
m_firstPath = converter.WStringToString(fileName);
m_guiFirstPath = qFilePath.toStdString();
}
else
{
m_firstPath = "";
m_guiFirstPath = "";
}
}
ui->openTextBrowser->setText(QString::fromStdString(m_guiFirstPath));
}
void MainWindow::nmea_slot()
{
int ret;
ret = getFilePaths();
if(ret == 0)
{
vector<string> kmlPaths; // 存储输出的kml文件路径
vector<string>::iterator iter;
for(iter = m_filePaths.begin(); iter != m_filePaths.end(); ++iter)
{
ifstream ifstr(*iter, ios_base::binary | ios_base::in);
string outputFilePath = (*iter) + ".kml";
ofstream* pOfstr = new ofstream(outputFilePath, ios_base::out | ios_base::binary | ios_base::trunc);
if(pOfstr == NULL)
{
QString message = QString(tr("打开(创建)输出文件(")) + QString::fromStdString(outputFilePath) + QString(tr(")失败"));
QMessageBox msgBox(QMessageBox::Warning,"Information",message,QMessageBox::Yes,NULL);
msgBox.exec();
continue;
}
else if(!pOfstr->is_open())
{
QString message = QString(tr("打开(创建)输出文件(")) + QString::fromStdString(outputFilePath) + QString(tr(")失败"));
QMessageBox msgBox(QMessageBox::Warning,"Information",message,QMessageBox::Yes,NULL);
msgBox.exec();
continue;
}
if(ifstr.is_open())
{
int isFirst = 1;
vector<string> kmlPointInfo;
int emptyCnt = 0;
char bufPos[64] = {0};
while(1)
{
char buf[256] = {0};
ifstr.getline(buf, sizeof(buf));
int buflen = strlen((const char*)buf);
if(buflen > 32)
{
vector<string> substrs;
ret = splitString1(string(buf), substrs, ',');
if(ret < 0)
{
continue;
}
if(isFirst)
{
kmlPointInfo.clear();
kmlPointInfo.push_back(outputFilePath);
ret = convertToKMLWithoutName(kmlPointInfo, pOfstr, 0); //
if(ret < 0)
{
continue;
}
isFirst = 0;
}
if(!isFirst)
{
kmlPointInfo.clear();
kmlPointInfo.push_back(substrs[1]); // utcTime
double lonDDPointDDDD;
double lonDDMMPointMMMM;
stringstream sLon1(substrs[4]);
sLon1 >> lonDDMMPointMMMM;
fromDMToDegree(lonDDMMPointMMMM, lonDDPointDDDD);
memset(bufPos, 0, sizeof(bufPos));
sprintf(bufPos, "%lf", lonDDPointDDDD);
kmlPointInfo.push_back(string(bufPos)); // Lon: 经度
double latDDPointDDDD;
double latDDMMPointMMMM;
stringstream sLat1(substrs[2]);
sLat1 >> latDDMMPointMMMM;
fromDMToDegree(latDDMMPointMMMM, latDDPointDDDD);
memset(bufPos, 0, sizeof(bufPos));
sprintf(bufPos, "%lf", latDDPointDDDD);
kmlPointInfo.push_back(string(bufPos)); // Lat
ret = convertToKMLWithoutName(kmlPointInfo, pOfstr, 1);
if(ret < 0)
{
continue;
}
}
emptyCnt = 0;
continue;
}
else if(buflen > 0)
{
emptyCnt = 0;
continue;
}
else
{
emptyCnt++;
}
if(emptyCnt > 20)
{
break;
}
}
ret = convertToKMLWithoutName(kmlPointInfo, pOfstr, 2); // kml 文件结束
ifstr.close();
pOfstr->close();
delete pOfstr;
pOfstr = NULL;
kmlPaths.push_back(outputFilePath);
QMessageBox msgBox(QMessageBox::Warning,"Information",tr("处理完成"),QMessageBox::Yes,NULL);
msgBox.exec();
}
else
{
QString message = QString(tr("打开文件(")) + QString::fromStdString(*iter) + QString(tr(")失败"));
QMessageBox msgBox(QMessageBox::Warning,"Information",message,QMessageBox::Yes,NULL);
msgBox.exec();
}
}//for
// 利用Google Earth 自动打开
if(m_isAuto)
{
CTMStrConvert converter;
wstring googleEarthPath = converter.StringToWString(m_googleEarthPath);
vector<string>::iterator iterKmlPath;
if(m_isSplit)
{// 每个KML文件单独显示
for(iterKmlPath = kmlPaths.begin(); iterKmlPath != kmlPaths.end(); ++iterKmlPath)
{
string kmlPath = *iterKmlPath;
wstring wkmlPath = converter.StringToWString(kmlPath);
HINSTANCE ret = ShellExecute(NULL, L"open", googleEarthPath.c_str(), wkmlPath.c_str(), NULL, SW_SHOWNORMAL);
if((int)ret < 32)
{
int errorNo = (int)ret;
QString message = QString(tr("启动Google Earth 显示 KML 文件：("))
+ QString::fromStdString(kmlPath)
+ QString(tr(") 失败, Error Code: "))
+ QString::number(errorNo);
QMessageBox msgBox(QMessageBox::Warning,"Information",message,QMessageBox::Yes,NULL);
msgBox.exec();
}
}
}
else
{// 全部KML文件同时显示
wstring wkmlPath;
for(iterKmlPath = kmlPaths.begin(); iterKmlPath != kmlPaths.end(); ++iterKmlPath)
{
string kmlPath = *iterKmlPath;
wkmlPath += converter.StringToWString(kmlPath) + wstring(L" ");
}
HINSTANCE ret = ShellExecute(NULL, L"open", googleEarthPath.c_str(), wkmlPath.c_str(), NULL, SW_SHOWNORMAL);
if((int)ret < 32)
{
int errorNo = (int)ret;
QString message = QString(tr("启动Google Earth 显示 KML 文件失败, Error Code: ")) + QString::number(errorNo);
QMessageBox msgBox(QMessageBox::Warning,"Information",message,QMessageBox::Yes,NULL);
msgBox.exec();
}
}
}// if m_isAuto
}// if ret
}
int MainWindow::getFilePaths()
{
if(m_firstPath.empty())
{
QMessageBox msgBox(QMessageBox::Warning,"Information",tr("未选择文件(夹),请选择"),QMessageBox::Yes,NULL);
msgBox.exec();
return -1;
}
// 清空路径
if(!m_filePaths.empty())
{
m_filePaths.clear();
}
if(m_isBatch)
{// 遍历文件夹
QDir dir(QString::fromStdString(m_firstPath));
int supportCnt = m_supportFormat.supportTXT + m_supportFormat.supportCSV + m_supportFormat.supportRDF;
if(supportCnt == 0)
{
QMessageBox msgBox(QMessageBox::Warning,"Information",tr("文件夹中无.txt/.csv/.rdf文件格式文件，请确定"),QMessageBox::Yes,NULL);
msgBox.exec();
return -1;
}
foreach(QFileInfo mfi ,dir.entryInfoList())
{
if(mfi.isFile())
{
QString filePath = mfi.filePath();
QString fileName = mfi.fileName();
string sfileName = fileName.toLower().toStdString();
if(m_supportFormat.supportTXT)
{
if(sfileName.find(".txt") != string::npos)
{
QTextCodec *codec = QTextCodec::codecForName("UTF-8");
QString str = codec->toUnicode(filePath.toStdString().c_str());
wstring wFilePath = str.toStdWString();
CTMStrConvert converter;
m_filePaths.push_back(converter.WStringToString(wFilePath));
// m_filePaths.push_back(filePath.toStdString());
}
}
if(m_supportFormat.supportCSV)
{
if(sfileName.find(".csv") != string::npos)
{
QTextCodec *codec =QTextCodec::codecForName("UTF-8");
QString str = codec->toUnicode(filePath.toStdString().c_str());
wstring wFilePath = str.toStdWString();
CTMStrConvert converter;
m_filePaths.push_back(converter.WStringToString(wFilePath));
// m_filePaths.push_back(filePath.toStdString());
}
}
if(m_supportFormat.supportRDF)
{
if(sfileName.find(".rdf") != string::npos)
{
QTextCodec *codec =QTextCodec::codecForName("UTF-8");
QString str = codec->toUnicode(filePath.toStdString().c_str());
wstring wFilePath = str.toStdWString();
CTMStrConvert converter;
m_filePaths.push_back(converter.WStringToString(wFilePath));
// m_filePaths.push_back(filePath.toStdString());
}
}
}
else
{
continue;
}
}
}
else
{
m_filePaths.push_back(m_firstPath);
}
if(m_filePaths.size() == 0)
{
QMessageBox msgBox(QMessageBox::Warning,"Information",tr("无有效文件，请确定"),QMessageBox::Yes,NULL);
msgBox.exec();
return -1;
}
return 0;
}

2.4 UI文件请到如下路径下载，同时也包含可执行文件(.exe)：

https://download.csdn.net/download/hit1524468/10316766

3. 工具效果(选择用googleEarth打开转换的KML文件)

伊伊_f

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
NMEA数据转Google Earth的KML工具

1. 背景在关于GPS定位的研究分析过程中，经常想要看在一段测试路径上，GPS的定位准确性如何，实际上，很自然的会想到把GPS数据显示在地图上，然而，并且，Google提供的Google Earth就是一个不错的工具，至于为什么不选择别的地图工具，是因为别的地图需要进行WGS84坐标系进行转换。2. 实现代码2.1 NMEA格式数据转化为KML的头文件 #ifndef CONVERT_H #define CONVERT_H #include <iostr.
复制链接

扫一扫

专栏目录